1 /*
2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License
4 * as published by the Free Software Foundation; either version 2
5 * of the License, or (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15 *
16 * The Original Code is Copyright (C) 2013 Blender Foundation.
17 * All rights reserved.
18 */
19
20 #include "libmv-capi.h"
21
22 #include <cstdlib>
23 #include <cstring>
24
25 /* ************ Logging ************ */
26
libmv_initLogging(const char *)27 void libmv_initLogging(const char * /*argv0*/) {
28 }
29
libmv_startDebugLogging(void)30 void libmv_startDebugLogging(void) {
31 }
32
libmv_setLoggingVerbosity(int)33 void libmv_setLoggingVerbosity(int /*verbosity*/) {
34 }
35
36 /* ************ Planar tracker ************ */
37
38 /* TrackRegion (new planar tracker) */
libmv_trackRegion(const libmv_TrackRegionOptions *,const float *,int,int,const float *,int,int,const double * x1,const double * y1,libmv_TrackRegionResult * result,double * x2,double * y2)39 int libmv_trackRegion(const libmv_TrackRegionOptions * /*options*/,
40 const float * /*image1*/,
41 int /*image1_width*/,
42 int /*image1_height*/,
43 const float * /*image2*/,
44 int /*image2_width*/,
45 int /*image2_height*/,
46 const double *x1,
47 const double *y1,
48 libmv_TrackRegionResult *result,
49 double *x2,
50 double *y2) {
51 /* Convert to doubles for the libmv api. The four corners and the center. */
52 for (int i = 0; i < 5; ++i) {
53 x2[i] = x1[i];
54 y2[i] = y1[i];
55 }
56
57 result->termination = -1;
58 result->termination_reason = "Built without libmv support";
59 result->correlation = 0.0;
60
61 return false;
62 }
63
libmv_samplePlanarPatchFloat(const float *,int,int,int,const double *,const double *,int,int,const float *,float *,double *,double *)64 void libmv_samplePlanarPatchFloat(const float * /*image*/,
65 int /*width*/,
66 int /*height*/,
67 int /*channels*/,
68 const double * /*xs*/,
69 const double * /*ys*/,
70 int /*num_samples_x*/,
71 int /*num_samples_y*/,
72 const float * /*mask*/,
73 float * /*patch*/,
74 double * /*warped_position_x*/,
75 double * /*warped_position_y*/) {
76 /* TODO(sergey): implement */
77 }
78
libmv_samplePlanarPatchByte(const unsigned char *,int,int,int,const double *,const double *,int,int,const float *,unsigned char *,double *,double *)79 void libmv_samplePlanarPatchByte(const unsigned char * /*image*/,
80 int /*width*/,
81 int /*height*/,
82 int /*channels*/,
83 const double * /*xs*/,
84 const double * /*ys*/,
85 int /*num_samples_x*/, int /*num_samples_y*/,
86 const float * /*mask*/,
87 unsigned char * /*patch*/,
88 double * /*warped_position_x*/,
89 double * /*warped_position_y*/) {
90 /* TODO(sergey): implement */
91 }
92
libmv_floatImageDestroy(libmv_FloatImage *)93 void libmv_floatImageDestroy(libmv_FloatImage* /*image*/)
94 {
95 }
96
97 /* ************ Tracks ************ */
98
libmv_tracksNew(void)99 libmv_Tracks *libmv_tracksNew(void) {
100 return NULL;
101 }
102
libmv_tracksInsert(libmv_Tracks *,int,int,double,double,double)103 void libmv_tracksInsert(libmv_Tracks * /*libmv_tracks*/,
104 int /*image*/,
105 int /*track*/,
106 double /*x*/,
107 double /*y*/,
108 double /*weight*/) {
109 }
110
libmv_tracksDestroy(libmv_Tracks *)111 void libmv_tracksDestroy(libmv_Tracks * /*libmv_tracks*/) {
112 }
113
114 /* ************ Reconstruction solver ************ */
115
libmv_solveReconstruction(const libmv_Tracks *,const libmv_CameraIntrinsicsOptions *,libmv_ReconstructionOptions *,reconstruct_progress_update_cb,void *)116 libmv_Reconstruction *libmv_solveReconstruction(
117 const libmv_Tracks * /*libmv_tracks*/,
118 const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
119 libmv_ReconstructionOptions * /*libmv_reconstruction_options*/,
120 reconstruct_progress_update_cb /*progress_update_callback*/,
121 void * /*callback_customdata*/) {
122 return NULL;
123 }
124
libmv_solveModal(const libmv_Tracks *,const libmv_CameraIntrinsicsOptions *,const libmv_ReconstructionOptions *,reconstruct_progress_update_cb,void *)125 libmv_Reconstruction *libmv_solveModal(
126 const libmv_Tracks * /*libmv_tracks*/,
127 const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
128 const libmv_ReconstructionOptions * /*libmv_reconstruction_options*/,
129 reconstruct_progress_update_cb /*progress_update_callback*/,
130 void * /*callback_customdata*/) {
131 return NULL;
132 }
133
libmv_reconstructionIsValid(libmv_Reconstruction *)134 int libmv_reconstructionIsValid(libmv_Reconstruction * /*libmv_reconstruction*/) {
135 return 0;
136 }
137
libmv_reprojectionPointForTrack(const libmv_Reconstruction *,int,double[3])138 int libmv_reprojectionPointForTrack(
139 const libmv_Reconstruction * /*libmv_reconstruction*/,
140 int /*track*/,
141 double /*pos*/[3]) {
142 return 0;
143 }
144
libmv_reprojectionErrorForTrack(const libmv_Reconstruction *,int)145 double libmv_reprojectionErrorForTrack(
146 const libmv_Reconstruction * /*libmv_reconstruction*/,
147 int /*track*/) {
148 return 0.0;
149 }
150
libmv_reprojectionErrorForImage(const libmv_Reconstruction *,int)151 double libmv_reprojectionErrorForImage(
152 const libmv_Reconstruction * /*libmv_reconstruction*/,
153 int /*image*/) {
154 return 0.0;
155 }
156
libmv_reprojectionCameraForImage(const libmv_Reconstruction *,int,double[4][4])157 int libmv_reprojectionCameraForImage(
158 const libmv_Reconstruction * /*libmv_reconstruction*/,
159 int /*image*/,
160 double /*mat*/[4][4]) {
161 return 0;
162 }
163
libmv_reprojectionError(const libmv_Reconstruction *)164 double libmv_reprojectionError(
165 const libmv_Reconstruction * /*libmv_reconstruction*/) {
166 return 0.0;
167 }
168
libmv_reconstructionDestroy(struct libmv_Reconstruction *)169 void libmv_reconstructionDestroy(
170 struct libmv_Reconstruction * /*libmv_reconstruction*/) {
171 }
172
173 /* ************ Feature detector ************ */
174
libmv_detectFeaturesByte(const unsigned char *,int,int,int,libmv_DetectOptions *)175 libmv_Features *libmv_detectFeaturesByte(const unsigned char * /*image_buffer*/,
176 int /*width*/,
177 int /*height*/,
178 int /*channels*/,
179 libmv_DetectOptions * /*options*/) {
180 return NULL;
181 }
182
libmv_detectFeaturesFloat(const float *,int,int,int,libmv_DetectOptions *)183 struct libmv_Features *libmv_detectFeaturesFloat(
184 const float * /*image_buffer*/,
185 int /*width*/,
186 int /*height*/,
187 int /*channels*/,
188 libmv_DetectOptions * /*options*/) {
189 return NULL;
190 }
191
libmv_countFeatures(const libmv_Features *)192 int libmv_countFeatures(const libmv_Features * /*libmv_features*/) {
193 return 0;
194 }
195
libmv_getFeature(const libmv_Features *,int,double * x,double * y,double * score,double * size)196 void libmv_getFeature(const libmv_Features * /*libmv_features*/,
197 int /*number*/,
198 double *x,
199 double *y,
200 double *score,
201 double *size) {
202 *x = 0.0;
203 *y = 0.0;
204 *score = 0.0;
205 *size = 0.0;
206 }
207
libmv_featuresDestroy(struct libmv_Features *)208 void libmv_featuresDestroy(struct libmv_Features * /*libmv_features*/) {
209 }
210
211 /* ************ Camera intrinsics ************ */
212
libmv_reconstructionExtractIntrinsics(libmv_Reconstruction *)213 libmv_CameraIntrinsics *libmv_reconstructionExtractIntrinsics(
214 libmv_Reconstruction * /*libmv_reconstruction*/) {
215 return NULL;
216 }
217
libmv_cameraIntrinsicsNew(const libmv_CameraIntrinsicsOptions *)218 libmv_CameraIntrinsics *libmv_cameraIntrinsicsNew(
219 const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/) {
220 return NULL;
221 }
222
libmv_cameraIntrinsicsCopy(const libmv_CameraIntrinsics *)223 libmv_CameraIntrinsics *libmv_cameraIntrinsicsCopy(
224 const libmv_CameraIntrinsics * /*libmvIntrinsics*/) {
225 return NULL;
226 }
227
libmv_cameraIntrinsicsDestroy(libmv_CameraIntrinsics *)228 void libmv_cameraIntrinsicsDestroy(
229 libmv_CameraIntrinsics * /*libmvIntrinsics*/) {
230 }
231
libmv_cameraIntrinsicsUpdate(const libmv_CameraIntrinsicsOptions *,libmv_CameraIntrinsics *)232 void libmv_cameraIntrinsicsUpdate(
233 const libmv_CameraIntrinsicsOptions * /*libmv_camera_intrinsics_options*/,
234 libmv_CameraIntrinsics * /*libmv_intrinsics*/) {
235 }
236
libmv_cameraIntrinsicsSetThreads(libmv_CameraIntrinsics *,int)237 void libmv_cameraIntrinsicsSetThreads(
238 libmv_CameraIntrinsics * /*libmv_intrinsics*/,
239 int /*threads*/) {
240 }
241
libmv_cameraIntrinsicsExtractOptions(const libmv_CameraIntrinsics *,libmv_CameraIntrinsicsOptions * camera_intrinsics_options)242 void libmv_cameraIntrinsicsExtractOptions(
243 const libmv_CameraIntrinsics * /*libmv_intrinsics*/,
244 libmv_CameraIntrinsicsOptions *camera_intrinsics_options) {
245 memset(camera_intrinsics_options, 0, sizeof(libmv_CameraIntrinsicsOptions));
246 camera_intrinsics_options->focal_length = 1.0;
247 }
248
libmv_cameraIntrinsicsUndistortByte(const libmv_CameraIntrinsics *,const unsigned char * source_image,int width,int height,float,int channels,unsigned char * destination_image)249 void libmv_cameraIntrinsicsUndistortByte(
250 const libmv_CameraIntrinsics * /*libmv_intrinsics*/,
251 const unsigned char *source_image,
252 int width, int height,
253 float /*overscan*/,
254 int channels,
255 unsigned char *destination_image) {
256 memcpy(destination_image, source_image,
257 channels * width * height * sizeof(unsigned char));
258 }
259
libmv_cameraIntrinsicsUndistortFloat(const libmv_CameraIntrinsics *,const float * source_image,int width,int height,float,int channels,float * destination_image)260 void libmv_cameraIntrinsicsUndistortFloat(
261 const libmv_CameraIntrinsics* /*libmv_intrinsics*/,
262 const float* source_image,
263 int width,
264 int height,
265 float /*overscan*/,
266 int channels,
267 float* destination_image) {
268 memcpy(destination_image, source_image,
269 channels * width * height * sizeof(float));
270 }
271
libmv_cameraIntrinsicsDistortByte(const struct libmv_CameraIntrinsics *,const unsigned char * source_image,int width,int height,float,int channels,unsigned char * destination_image)272 void libmv_cameraIntrinsicsDistortByte(
273 const struct libmv_CameraIntrinsics* /*libmv_intrinsics*/,
274 const unsigned char *source_image,
275 int width,
276 int height,
277 float /*overscan*/,
278 int channels,
279 unsigned char *destination_image) {
280 memcpy(destination_image, source_image,
281 channels * width * height * sizeof(unsigned char));
282 }
283
libmv_cameraIntrinsicsDistortFloat(const libmv_CameraIntrinsics *,float * source_image,int width,int height,float,int channels,float * destination_image)284 void libmv_cameraIntrinsicsDistortFloat(
285 const libmv_CameraIntrinsics* /*libmv_intrinsics*/,
286 float* source_image,
287 int width,
288 int height,
289 float /*overscan*/,
290 int channels,
291 float* destination_image) {
292 memcpy(destination_image, source_image,
293 channels * width * height * sizeof(float));
294 }
295
296 /* ************ utils ************ */
297
libmv_cameraIntrinsicsApply(const struct libmv_CameraIntrinsics *,double,double,double * x1,double * y1)298 void libmv_cameraIntrinsicsApply(
299 const struct libmv_CameraIntrinsics* /*libmv_intrinsics*/,
300 double /*x*/,
301 double /*y*/,
302 double* x1,
303 double* y1) {
304 *x1 = 0.0;
305 *y1 = 0.0;
306 }
307
libmv_cameraIntrinsicsInvert(const struct libmv_CameraIntrinsics *,double,double,double * x1,double * y1)308 void libmv_cameraIntrinsicsInvert(
309 const struct libmv_CameraIntrinsics* /*libmv_intrinsics*/,
310 double /*x*/,
311 double /*y*/,
312 double* x1,
313 double* y1) {
314 *x1 = 0.0;
315 *y1 = 0.0;
316 }
317
libmv_homography2DFromCorrespondencesEuc(double (*)[2],double (*)[2],int,double H[3][3])318 void libmv_homography2DFromCorrespondencesEuc(/* const */ double (* /*x1*/)[2],
319 /* const */ double (* /*x2*/)[2],
320 int /*num_points*/,
321 double H[3][3]) {
322 memset(H, 0, sizeof(double[3][3]));
323 H[0][0] = 1.0f;
324 H[1][1] = 1.0f;
325 H[2][2] = 1.0f;
326 }
327
328 /* ************ autotrack ************ */
329
libmv_autoTrackNew(libmv_FrameAccessor *)330 libmv_AutoTrack* libmv_autoTrackNew(libmv_FrameAccessor* /*frame_accessor*/)
331 {
332 return NULL;
333 }
334
libmv_autoTrackDestroy(libmv_AutoTrack *)335 void libmv_autoTrackDestroy(libmv_AutoTrack* /*libmv_autotrack*/)
336 {
337 }
338
libmv_autoTrackSetOptions(libmv_AutoTrack *,const libmv_AutoTrackOptions *)339 void libmv_autoTrackSetOptions(libmv_AutoTrack* /*libmv_autotrack*/,
340 const libmv_AutoTrackOptions* /*options*/)
341 {
342 }
343
libmv_autoTrackMarker(libmv_AutoTrack *,const libmv_TrackRegionOptions *,libmv_Marker *,libmv_TrackRegionResult *)344 int libmv_autoTrackMarker(libmv_AutoTrack* /*libmv_autotrack*/,
345 const libmv_TrackRegionOptions* /*libmv_options*/,
346 libmv_Marker * /*libmv_tracker_marker*/,
347 libmv_TrackRegionResult* /*libmv_result*/)
348 {
349 return 0;
350 }
351
libmv_autoTrackAddMarker(libmv_AutoTrack *,const libmv_Marker *)352 void libmv_autoTrackAddMarker(libmv_AutoTrack* /*libmv_autotrack*/,
353 const libmv_Marker* /*libmv_marker*/)
354 {
355 }
356
libmv_autoTrackSetMarkers(libmv_AutoTrack *,const libmv_Marker *,size_t)357 void libmv_autoTrackSetMarkers(libmv_AutoTrack* /*libmv_autotrack*/,
358 const libmv_Marker* /*libmv_marker-*/,
359 size_t /*num_markers*/)
360 {
361 }
362
libmv_autoTrackGetMarker(libmv_AutoTrack *,int,int,int,libmv_Marker *)363 int libmv_autoTrackGetMarker(libmv_AutoTrack* /*libmv_autotrack*/,
364 int /*clip*/,
365 int /*frame*/,
366 int /*track*/,
367 libmv_Marker* /*libmv_marker*/)
368 {
369 return 0;
370 }
371
372 /* ************ frame accessor ************ */
373
libmv_FrameAccessorNew(libmv_FrameAccessorUserData *,libmv_GetImageCallback,libmv_ReleaseImageCallback,libmv_GetMaskForTrackCallback,libmv_ReleaseMaskCallback)374 libmv_FrameAccessor* libmv_FrameAccessorNew(
375 libmv_FrameAccessorUserData* /*user_data**/,
376 libmv_GetImageCallback /*get_image_callback*/,
377 libmv_ReleaseImageCallback /*release_image_callback*/,
378 libmv_GetMaskForTrackCallback /*get_mask_for_track_callback*/,
379 libmv_ReleaseMaskCallback /*release_mask_callback*/)
380 {
381 return NULL;
382 }
383
libmv_FrameAccessorDestroy(libmv_FrameAccessor *)384 void libmv_FrameAccessorDestroy(libmv_FrameAccessor* /*frame_accessor*/)
385 {
386 }
387
libmv_frameAccessorgetTransformKey(const libmv_FrameTransform *)388 int64_t libmv_frameAccessorgetTransformKey(
389 const libmv_FrameTransform * /*transform*/)
390 {
391 return 0;
392 }
393
libmv_frameAccessorgetTransformRun(const libmv_FrameTransform *,const libmv_FloatImage *,libmv_FloatImage *)394 void libmv_frameAccessorgetTransformRun(const libmv_FrameTransform* /*transform*/,
395 const libmv_FloatImage* /*input_image*/,
396 libmv_FloatImage* /*output_image*/)
397 {
398 }
399
400