more standard functions

Author: dehann

src/Deprecated.jl

@@ -1,11 +1,8 @@
 
-
-
-
 ## ================================================================================================
-## consolidated types below
+## consolidated types from various repos in Julia ecosystem
+## ================================================================================================
 
-export CameraCalibrationT
 
 """
     CameraCalibrationT
@@ -189,18 +186,19 @@ end
 #   PinholeCamera(;f_w, f_h, c_w, c_h)
 # end
 
-
+@deprecate c_w(w...) pp_w(w...)
+@deprecate c_h(w...) pp_h(w...)
 # f_w(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[1,1]
 # f_h(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[2,2]
 # shear(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[1,2]
-# c_w(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[1,3]
-# c_h(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[2,3]
+# pp_w(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[1,3]
+# pp_h(pc::Union{CameraCalibration,CameraCalibrationMutable}) = pc.K[2,3]
 
 # set_f_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,1] = val)
 # set_f_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,2] = val)
 # set_shear!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,2] = val)
-# set_c_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,3] = val)
-# set_c_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,3] = val)
+# set_pp_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,3] = val)
+# set_pp_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,3] = val)
 
 
 export Pinhole

src/ExportAPI.jl

@@ -11,6 +11,7 @@ export Ray, PixelIndex
 export pixel2ray, point2pixel, canreproject, sensorsize #, origin, direction, 
 export project, projectHomogeneous
 export backproject, backprojectHomogeneous
+export pp_w, pp_h, f_w, f_h
 
 export lookdirection, updirection #, columns, rows
 

src/services/CameraServices.jl

@@ -15,31 +15,35 @@ direction(vector::Union{<:AbstractVector{<:Real},<:Vector3}) = vector
 direction(ray::Ray) = ray.direction
 sensorsize(cameramodel::AbstractCameraModel) = SVector{2}(width(cameramodel), height(cameramodel))
 
-"""
-    canreproject(camera::CameraModel)
-
-Confirms if point2pixel is implemented for this camera model.
-"""
-canreproject(camera::AbstractCameraModel) = true
-
-
 ## From JuliaRobotics/Caesar.jl
 f_w(pc::AbstractCameraModel) = pc.K[1,1]
 f_h(pc::AbstractCameraModel) = pc.K[2,2]
 shear(pc::AbstractCameraModel) = pc.K[1,2]
-c_w(pc::AbstractCameraModel) = pc.K[1,3]
-c_h(pc::AbstractCameraModel) = pc.K[2,3]
+pp_w(pc::AbstractCameraModel) = pc.K[1,3]
+pp_h(pc::AbstractCameraModel) = pc.K[2,3]
 
 set_f_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,1] = val)
 set_f_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,2] = val)
 set_shear!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,2] = val)
-set_c_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,3] = val)
-set_c_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,3] = val)
+set_pp_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,3] = val)
+set_pp_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,3] = val)
+
+"""
+    canreproject(camera::CameraModel)
+
+Confirms if point2pixel is implemented for this camera model.
+"""
+canreproject(camera::AbstractCameraModel) = true
 
 
 ## computational functions
 
 
+## =========================================================================================
+## FROM SCENE IN FRONT OF CAMERA TO IMAGE -- I.E. PROJECT
+## =========================================================================================
+
+
 
 """
     $SIGNATURES
@@ -51,23 +55,49 @@ to camera coordinates. This currently ignores any tangential
 distortion between the lens and the image plane.
 
 Notes
-- `pointincamera` is camera's reference frame.
+- `c_P` is a point in the camera's reference frame.
 
 Deprecates:
-- yakir12: `point2pixel`
+- yakir12: `point2pixel`: @deprecate point2pixel(model, pt) project(model, pt[[1;3;2]])
 
 Also see: [`backproject`](@ref)
 """
 function project(
     model::AbstractCameraModel,
-    pointincamera::Union{<:AbstractVector{<:Real}, <:Point3}
+    c_P::Union{<:AbstractVector{<:Real}, <:Point3}
   )
   #
-  column = c_w(model) + f_w(model) * pointincamera[1] / pointincamera[3]
-  row = c_h(model) - f_h(model) * pointincamera[2] / pointincamera[3]
+  column = pp_w(model) + f_w(model) * c_P[1] / c_P[3]
+  row = pp_h(model) - f_h(model) * c_P[2] / c_P[3]
   return PixelIndex(column, row)
 end
 
+## From JuliaRobotics/SensorFeatureTracking.jl
+function project!(
+  ret::AbstractVector{<:Real}, 
+  ci::CameraCalibration, #CameraIntrinsic, 
+  ce::ArrayPartition, 
+  pt::Vector{Float64}
+)
+  res = ci.K*(ce.R*pt + ce.t)
+  ret[1:2] = res[1:2]./res[3]
+  nothing
+end
+
+project!(
+  ret::AbstractVector{<:Real}, 
+  cm::CameraModelFull, 
+  pt::AbstractVector{<:Real}) = project!(ret, cm.ci, cm.ce, pt)
+
+function project(
+  cm::CameraModelFull, 
+  pt::AbstractVector{<:Real}
+)
+  res = Vector{Float64}(2)
+  project!(res, cm, pt)
+  return res
+end
+
 ## homogeneous point coords xyzw (stereo cameras)
 # xyzw are in the camera frame (c_), i.e. x-columns, y-rows, z-forward
 function projectHomogeneous(
@@ -78,21 +108,25 @@ function projectHomogeneous(
   x,y,z,w = (c_Ph...,)
   fxz = f_w(cam) / z
   fyz = f_h(cam) / z
-  w = x * fxz + c_w(cam) # add center to get PixelIndex
-  h = y * fyz + c_h(cam)
+  col = x * fxz + pp_w(cam) # add center to get PixelIndex
+  row = y * fyz + pp_h(cam)
+  # infront or behind
   if (w==0&&0<z) || 0 < (z/w)
-    PixelIndex(w,h)
+    PixelIndex(col,row)
   else
     PixelIndex(0.,0.; valid=false)
   end
 end
 # # right cam
 # u2 = (x - w*baseline) * fz + center[1]
-# # infront or behind
-# valid = (w==0&&0<z) || 0 < (z/w) 
 
 
 
+## =========================================================================================
+## FROM IMAGE TO SCENE IN FRONT OF CAMERA -- I.E. BACKPROJECT
+## =========================================================================================
+
+
 """
     $SIGNATURES
 
@@ -103,7 +137,7 @@ to camera coordinates. This currently ignores any tangential
 distortion between the lens and the image plane.
 
 Deprecates:
-- yakir12: `pixel2ray`
+- yakir12: `pixel2ray`: @deprecate pixel2ray(model, px) backproject(model, px)[[1;3;2]]
 
 Also see: [`project`](@ref)
 """
@@ -112,9 +146,9 @@ function backproject(
     px_coord::Union{<:AbstractVector{<:Real}, <:PixelIndex}
   )
   #
-  x =  (px_coord[1] - c_w(model)) / f_w(model)
-  y = -(px_coord[2] - c_h(model)) / f_h(model)
-  return Vector3(x, y, 1)
+  col =  (px_coord[1] - pp_w(model)) / f_w(model)
+  row = -(px_coord[2] - pp_h(model)) / f_h(model)
+  return Vector3(col, row, 1)
 end
 # # camera measurements (u,v), (u2,v)
 # lx = (u-center[1])*baseline
@@ -128,45 +162,18 @@ end
 
 
 ## =========================================================================================
-## REFACTOR AND CONSOLIDATE BELOW
+## RESIDUAL FUNCTION FOR OPTIMIZATION OR LOSS
 ## =========================================================================================
 
 
-## From JuliaRobotics/SensorFeatureTracking.jl
-
-function project!(
-  ret::AbstractVector{<:Real}, 
-  ci::CameraCalibration, #CameraIntrinsic, 
-  ce::ArrayPartition, 
-  pt::Vector{Float64}
-)
-  res = ci.K*(ce.R*pt + ce.t)
-  ret[1:2] = res[1:2]./res[3]
-  nothing
-end
-
-project!(
-  ret::AbstractVector{<:Real}, 
-  cm::CameraModelFull, 
-  pt::AbstractVector{<:Real}) = project!(ret, cm.ci, cm.ce, pt)
-
-function project(
-  cm::CameraModelFull, 
-  pt::AbstractVector{<:Real}
-)
-  res = Vector{Float64}(2)
-  project!(res, cm, pt)
-  return res
-end
-
 # pinhole camera model
 # (x, y)/f = (X, Y)/Z
 function cameraResidual!(
     res::AbstractVector{<:Real},
     z::AbstractVector{<:Real},
     ci::CameraCalibration, #CameraIntrinsic,
     ce::ArrayPartition,
-    pt::AbstractVector{<:Real}  
+    pt::Union{PixelIndex,<:AbstractVector{<:Real}},  
   )
   # in place memory operations
   project!(res, ci, ce, pt)