Merge pull request #18 from JuliaRobotics/23Q1/depr/dropcamcalT

drop CameraCalibrationT

Author: dehann

src/Deprecated.jl

@@ -5,6 +5,15 @@
 ## ================================================================================================
 ## consolidated types below
 
+export CameraCalibrationT
+
+"""
+    CameraCalibrationT
+
+A Union type for users to implement against both `struct`` and `mutable struct` definitions of `CameraCalibration`
+"""
+CameraCalibrationT = Union{<:CameraCalibration, <:CameraCalibrationMutable}
+
 @deprecate CameraExtrinsic(R::AbstractMatrix=[1 0 0; 0 1 0; 0 0 1.], t::AbstractVector=[0,0,0.]) ArrayPartition(SVector(t...),SMatrix(R))
 
 # Camera extrinsic must be world in camera frame (cRw)

src/ExportAPI.jl

@@ -3,7 +3,7 @@
 
 export AbstractCameraModel
 
-export CameraCalibrationT, CameraCalibration, CameraCalibrationMutable
+export CameraCalibration, CameraCalibrationMutable
 
 export CameraSkewDistortion
 

src/entities/CameraCalibration.jl

@@ -25,13 +25,13 @@ Notes
   - Direct comparison with [OpenCV convention](https://docs.opencv.org/3.4/d9/d0c/group__calib3d.html) is:
     - `(x,y) [CamXYZ] <==> (j,i) [Images.jl] <==> (u,v) [OpenCV]` -- look very carfully at `(u,v) <==> (j,i)` in *image-frame*
 - Always follow right hand rule for everything.
-- A convenience Union type [`CameraCalibrationT`](@ref) is provided to develop implementations against `struct` and `mutable struct` types.
+- An abstract type [`AbstractCameraModel`](@ref) is provided to develop implementations against `struct` and `mutable struct` types.
 
 DevNotes
 - https://en.wikipedia.org/wiki/Distortion_(optics)
 
 
-Also see: [`CameraCalibrationT`](@ref) [`CameraCalibrationMutable`](@ref), (TODO: `ProjectiveCameraModel`)
+Also see: [`AbstractCameraModel`](@ref) [`CameraCalibrationMutable`](@ref), (TODO: `ProjectiveCameraModel`)
 """
 Base.@kwdef struct CameraCalibration{R <: Real,N} <: AbstractCameraModel
   """ number of pixels from top to bottom """
@@ -66,12 +66,6 @@ Base.@kwdef mutable struct CameraCalibrationMutable{R <: Real,N} <: AbstractCame
 end
 
 
-"""
-    CameraCalibrationT
-
-A Union type for users to implement against both `struct`` and `mutable struct` definitions of `CameraCalibration`
-"""
-CameraCalibrationT = Union{<:CameraCalibration, <:CameraCalibrationMutable}
 
 
 

src/services/CameraServices.jl

@@ -7,10 +7,10 @@
 ## From yakir12/CameraModels.jl
 origin(vector::Union{<:AbstractVector{<:Real},<:Vector3}) = origin3d
 origin(ray::Ray) = ray.origin
-lookdirection(cameramodel::CameraCalibrationT) = SVector{3}(0,1,0)
-updirection(cameramodel::CameraCalibrationT) = SVector{3}(0,0,1)
-width(cameramodel::CameraCalibrationT) = cameramodel.width
-height(cameramodel::CameraCalibrationT) = cameramodel.height 
+lookdirection(cameramodel::AbstractCameraModel) = SVector{3}(0,1,0)
+updirection(cameramodel::AbstractCameraModel) = SVector{3}(0,0,1)
+width(cameramodel::AbstractCameraModel) = cameramodel.width
+height(cameramodel::AbstractCameraModel) = cameramodel.height 
 direction(vector::Union{<:AbstractVector{<:Real},<:Vector3}) = vector
 direction(ray::Ray) = ray.direction
 sensorsize(cameramodel::AbstractCameraModel) = SVector{2}(width(cameramodel), height(cameramodel))
@@ -24,11 +24,11 @@ canreproject(camera::AbstractCameraModel) = true
 
 
 ## From JuliaRobotics/Caesar.jl
-f_w(pc::CameraCalibrationT) = pc.K[1,1]
-f_h(pc::CameraCalibrationT) = pc.K[2,2]
-shear(pc::CameraCalibrationT) = pc.K[1,2]
-c_w(pc::CameraCalibrationT) = pc.K[1,3]
-c_h(pc::CameraCalibrationT) = pc.K[2,3]
+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]
 
 set_f_w!(pc::CameraCalibrationMutable, val::Real) = (pc.K[1,1] = val)
 set_f_h!(pc::CameraCalibrationMutable, val::Real) = (pc.K[2,2] = val)
@@ -59,13 +59,13 @@ Deprecates:
 Also see: [`backproject`](@ref)
 """
 function project(
-    model::CameraCalibrationT,
+    model::AbstractCameraModel,
     pointincamera::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]
-  return PixelCoordinate(column, row)
+  return PixelIndex(column, row)
 end
 ## homogeneous point coords xyzw (stereo cameras)
 # # xyzw are in the camera frame, i.e. x-columns, y-rows, z-forward
@@ -95,9 +95,9 @@ Deprecates:
 Also see: [`project`](@ref)
 """
 function backproject(
-    model::CameraCalibrationT, 
-    px_coord::Union{<:AbstractVector{<:Real}, <:PixelIndex}
-  )
+  model::AbstractCameraModel, # AbstractCameraModel, 
+  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)

src/services/Prototypes.jl

@@ -37,18 +37,20 @@ Return the size of the camera sensor. By default calling out to columns(model) a
 function sensorsize end
 
 """
-    pixel2ray(cameramodel::AbstractCameraModel, pixelcoordinate::$(PixelCoordinate))
+    pixel2ray(cameramodel::AbstractCameraModel, pixelIndex::$(PixelIndex))
 
-Returns the ray in space (origin + direction) corresponding to this `pixelcoordinate`.
+Returns the ray in space (origin + direction) corresponding to this `pixelIndex`.
 """
 function pixel2ray end
+function backproject end
 
 """
     point2pixel(camera::AbstractCameraModel, pointincamera::$(Point3))
 
 Returns the pixel location onto which the 3D coordinate `pointincamera` is projected.
 """
 function point2pixel end
+function project end
 
 """
     lookdirection(camera::AbstractCameraModel)