| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
img_feature.cpp
Go to the documentation of this file.
1
9 #include <math.h>
10 #include <time.h>
11 #include "img_feature.h"
12 #include "img_mask.h"
13 #include "marker.h"
14 #include "linked_list.h"
15 #include "utilities.h"
16
17 // Declaration of global variables
18 extern int verbose; // Level of output to the screen
19
20 // Internal function prototypes
21 int img_replace_maxima2(Bimage* p, float threshold);
22
39 int img_replace_maxima(Bimage* p, float threshold)
40 {
41 Bimage* ptemp = NULL;
42 unsigned long i, j, n, imgsize = p->channels()*p->sizeX()*p->sizeY()*p->sizeZ();
43
44 for ( i=n=0; n<p->images(); n++ ) {
45 ptemp = p->extract(n);
46 ptemp->average(p->average());
47 img_replace_maxima2(ptemp, threshold);
48 if ( p->data_type() == UCharacter ) ptemp->truncate_to_min_max(0, 255);
49 ptemp->change_type(p->data_type());
50 for ( j=0; j<imgsize; i++, j++ ) p->set(i, (*ptemp)[j]);
51 delete ptemp;
52 }
53
54 return 0;
55 }
56
57 /*
58 @brief Replaces maxima above a threshold using local averages.
59
60 The image is first segemented into features, each defined as a
61 contiguous cluster of voxels with values above the threshold.
62 Each feature is encoded in an integer image, with all the values
63 in this image set to the indices of the features, or zero elsewhere.
64 The features are iteratively filled in, where in every iteration,
65 the border values of the features are replaced by the average
66 of the neighbouring voxels outside the feature. After each iteration,
67 every feature is shrunk by excluding the newly replaced voxels.
68 @param *p image (modified to floating point).
69 float threshold threshold.
70 @return int 0.
71 **/
72 int img_replace_maxima2(Bimage* p, float threshold)
73 {
74 Bimage* pfeature = img_find_features(p, threshold, 0, 0);
75
76 if ( verbose & ( VERB_LABEL | VERB_PROCESS ) ) {
77 cout << "Replacing maxima above: " << threshold << endl;
78 cout << "Number of maxima: " << pfeature->maximum() << endl << endl;
79 } else if ( verbose & VERB_LABEL )
80 cout << "Replacing maxima above: " << threshold << endl << endl;
81
82 if ( pfeature->maximum() < 1 ) { // No features found = no modification
83 delete pfeature;
84 return 0;
85 }
86
87 unsigned long i, j, k, m, n, x, y, z, iter;
88 long xx, yy, zz, nval, tx, ty, tz;
89 unsigned long nf = (unsigned long) (pfeature->maximum() + 1.5);
90 double val;
91 Vector3<int> lo, hi, feature_size;
92
93 int* num = new int[nf];
94 int* nimg = new int[nf];
95 Vector3<float>* feat = new Vector3<float>[nf];
96 Vector3<int>* min = new Vector3<int>[nf];
97 Vector3<int>* max = new Vector3<int>[nf];
98 float* temp;
99
100 for ( j=1; j<nf; j++ ) {
101 min[j][0] = p->sizeX();
102 min[j][1] = p->sizeY();
103 min[j][2] = p->sizeZ();
104 }
105
106 for ( i=n=0; n<p->images(); n++ ) {
107 for ( z=0; z<p->sizeZ(); z++ ) {
108 for ( y=0; y<p->sizeY(); y++ ) {
109 for ( x=0; x<p->sizeX(); x++, i++ ) {
110 j = (unsigned long) (*pfeature)[i];
111 if ( j ) {
112 num[j]++;
113 nimg[j] = n;
114 feat[j][0] += x;
115 feat[j][1] += y;
116 feat[j][2] += z;
117 if ( min[j].x() > x ) min[j][0] = x;
118 if ( min[j].y() > y ) min[j][1] = y;
119 if ( min[j].z() > z ) min[j][2] = z;
120 if ( max[j].x() < x ) max[j][0] = x;
121 if ( max[j].y() < y ) max[j][1] = y;
122 if ( max[j].z() < z ) max[j][2] = z;
123 }
124 }
125 }
126 }
127 }
128
129 if ( verbose & VERB_STATS )
130 cout << "Features:\n#\tImage\tx\ty\tz\tSize" << endl;
131 for ( j=1; j<nf; j++ ) {
132 n = nimg[j];
133 if ( num[j] ) feat[j] /= num[j];
134 if ( verbose & VERB_STATS )
135 cout << j << tab << n << tab << feat[j].x() << tab << feat[j].y() << tab << feat[j].z() << tab << num[j] << endl;
136 min[j] = min[j].max(0);
137 if ( max[j].x() >= p->sizeX() ) max[j][0] = p->sizeX() - 1;
138 if ( max[j].y() >= p->sizeY() ) max[j][1] = p->sizeY() - 1;
139 if ( max[j].z() >= p->sizeZ() ) max[j][2] = p->sizeZ() - 1;
140 feature_size[0] = max[j].x() - min[j].x() + 1;
141 feature_size[1] = max[j].y() - min[j].y() + 1;
142 feature_size[2] = max[j].z() - min[j].z() + 1;
143 temp = new float[feature_size.x()*feature_size.y()*feature_size.z()];
144 nval = iter = 0;
145 val = 0;
146 while ( nval < num[j] ) {
147 for ( k=0; k<feature_size.volume(); k++ )
148 temp[k] = p->minimum();
149 for ( z=min[j].z(); z<=max[j].z(); z++ ) {
150 tz = z - min[j].z();
151 lo[2] = ( z > 0 )? z - 1: 0;
152 hi[2] = ( z < p->sizeZ() - 1 )? z + 1: p->sizeZ() - 1;
153 for ( y=min[j].y(); y<=max[j].y(); y++ ) {
154 ty = y - min[j].y();
155 lo[1] = ( y > 0 )? y - 1: 0;
156 hi[1] = ( y < p->sizeY() - 1 )? y + 1: p->sizeY() - 1;
157 for ( x=min[j].x(); x<=max[j].x(); x++ ) {
158 tx = x - min[j].x();
159 lo[0] = ( x > 0 )? x - 1: 0;
160 hi[0] = ( x < p->sizeX() - 1 )? x + 1: p->sizeX() - 1;
161 // i = ((n*p->sizeZ() + z)*p->y + y)*p->x + x;
162 i = p->index(0,x,y,z,n);
163 if ( (*pfeature)[i] == j ) {
164 val = 0;
165 m = 0;
166 for ( zz=lo.z(); zz<=hi.z(); zz++ ) {
167 for ( yy=lo.y(); yy<=hi.y(); yy++ ) {
168 for ( xx=lo.x(); xx<=hi.x(); xx++ ) {
169 // k = ((n*p->sizeZ() + zz)*p->y + yy)*p->x + xx;
170 k = p->index(0,xx,yy,zz,n);
171 if ( (*pfeature)[k] < 1 ) {
172 val += (*p)[k];
173 m++;
174 }
175 }
176 }
177 }
178 if ( m ) {
179 k = (tz*feature_size.y() + ty)*feature_size.x() + tx;
180 temp[k] = val/m;
181 }
182 }
183 }
184 }
185 }
186 for ( z=min[j].z(); z<=max[j].z(); z++ ) {
187 tz = z - min[j].z();
188 for ( y=min[j].y(); y<=max[j].y(); y++ ) {
189 ty = y - min[j].y();
190 for ( x=min[j].x(); x<=max[j].x(); x++ ) {
191 tx = x - min[j].x();
192 // i = ((n*p->sizeZ() + z)*p->y + y)*p->x + x;
193 i = p->index(0,x,y,z,n);
194 k = (tz*feature_size.y() + ty)*feature_size.x() + tx;
195 if ( temp[k] > p->minimum() ) {
196 p->set(i, temp[k]);
197 if ( (*pfeature)[i] == j ) pfeature->set(i, 0);
198 nval++;
199 }
200 }
201 }
202 }
203 iter++;
204 if ( verbose & VERB_FULL )
205 cout << iter << ":\t" << nval << endl;
206 }
207 delete[] temp;
208 }
209 if ( verbose & ( VERB_STATS | VERB_FULL ) )
210 cout << endl;
211
212 delete[] num;
213 delete[] nimg;
214 delete[] feat;
215 delete[] min;
216 delete[] max;
217
218 delete pfeature;
219
220 return 0;
221 }
222
249 Bmarker* img_extract_features(Bimage* p, int extract_method,
250 int target_num, float threshold)
251 {
252 // Convert to floating point to simplify operations
253 p->change_type(Float);
254
255 // The image is normalized so that the threshold, which is
256 // in terms of stddev units, makes sense.
257 // p->rescale_to_avg_std(0.0, 1.0);
258
259 // The extreme considered as a feature depends on the relative threshold
260 int sign = 1;
261 if ( threshold < p->average() ) sign = -1;
262 double abs_threshold = sign*threshold;
263
264 unsigned long datasize = p->data_size();
265 unsigned long i, x, y, z, n;
266 unsigned long count = 0;
267 double temp;
268 int* feature_mask = new int[datasize];
269 for ( i=0; i<datasize; i++ ) feature_mask[i] = 0;
270
271 if ( verbose & VERB_LABEL ) {
272 cout << "Using the ";
273 switch ( extract_method ) {
274 case 1: cout << "center of mass "; break;
275 case 2: cout << "center of volume "; break;
276 case 3: cout << "highest pixel density "; break;
277 default: cout << "center of mass "; break;
278 }
279 cout << "to determine the feature coordinates in " << p->file_name() << endl;
280 }
281
282 //Using a mask, all the features are grouped and numbered.
283 for ( i=0; i<datasize; i++ ) {
284 if ( sign*(*p)[i] > abs_threshold ) {
285 if ( feature_mask[i] == 0 ) {
286 //cout << "Feature %d\t%d\n", count + 1, i);
287 count ++;
288 img_assignAllMyNeighbors(p, feature_mask, i, count, threshold, 0, 0);
289 }
290 }
291 }
292
293 if ( verbose & VERB_LABEL )
294 cout << "Features extracted: " << count << endl << endl;
295
296 if ( count < 1 ) {
297 delete[] feature_mask;
298 return NULL;
299 }
300
301 Bmarker* set = NULL;
302 Bmarker* m = NULL;
303 Bmarker** lut = new Bmarker*[count];
304
305 for ( i=0; i<count; i++ ) {
306 m = (Bmarker *) add_item((char **) &m, sizeof(Bmarker));
307 if ( !set ) set = m;
308 m->id = i+1;
309 m->sel = i+1;
310 lut[i] = m;
311 }
312
313 for ( i=n=0; n<p->images(); n++ ) {
314 for ( z=0; z<p->sizeZ(); z++ ) {
315 for ( y=0; y<p->sizeY(); y++ ) {
316 for ( x=0; x<p->sizeX(); x++, i++ ) {
317 if ( feature_mask[i] > 0 ) { //meaning that it belongs to a group
318 m = lut[feature_mask[i]-1];
319 // cout << "Feature " << i << ": " << feature_mask[i] << endl;
320 temp = fabs((*p)[i]);
321 if ( extract_method == 1 ) {
322 m->loc[0] += temp*x;
323 m->loc[1] += temp*y;
324 m->loc[2] += temp*z;
325 m->fom += temp;
326 } else if ( extract_method == 2 ) {
327 m->loc[0] += x;
328 m->loc[1] += y;
329 m->loc[2] += z;
330 m->fom += 1;
331 }
332 if ( sign*(*p)[i] > sign*m->fom ) {
333 m->fom = (*p)[i];
334 if ( extract_method == 3 ) {
335 m->loc[0] = x;
336 m->loc[1] = y;
337 m->loc[2] = z;
338 }
339 }
340 m->img_num = n;
341 }
342 }
343 }
344 }
345 }
346
347 delete[] feature_mask;
348 delete[] lut;
349
350 cout << "Feature marker list generated" << endl;
351
352 markers_limit(target_num, sign, &set);
353
354 // if ( verbose & VERB_FULL )
355 cout << "Feature\tx\ty\tz\tex\tey\tez\tFOM" << endl;
356
357 for ( m=set; m; m=m->next ) {
358 if ( extract_method == 1 || extract_method == 2 )
359 m->loc /= m->fom;
360 m->err[0] = m->loc.x() - p->sizeX() /2;
361 m->err[1] = m->loc.y() - p->sizeY() /2;
362 m->err[2] = m->loc.z() - p->sizeZ() /2;
363 // if ( verbose & VERB_FULL )
364 cout << m->id << tab << m->loc.x() << tab << m->loc.y() << tab << m->loc.z() << tab <<
365 m->err.x() << tab << m->err.y() << tab << m->err.z() << tab << m->fom << endl;
366 }
367 if ( verbose & VERB_FULL )
368 cout << endl;
369
370 if ( verbose & VERB_DEBUG ) {
371 cout << "\nDEBUG img_extract_features: The Feature set" << endl;
372 for ( m=set; m; m=m->next )
373 cout << "Feature " << m->id << ": " << m->loc << tab << m->fom << endl;
374 Bimage* pmask = p->mask_by_threshold(threshold);
375 Bstring filename = p->file_name().pre_rev('.') + "_features.pif";
376 write_img(filename, pmask);
377 delete pmask;
378 }
379
380
381 return set;
382 }
383
407 Bimage* img_find_features(Bimage* p, float threshold, int sign, int wrap)
408 {
409 p->change_type(Float);
410
411 // The extreme considered as a feature depends on the threshold and sign
412 if ( sign < 0 ) sign = -1;
413 else if ( sign > 0 ) sign = 1;
414 else {
415 sign = 1;
416 if ( threshold < p->average() ) sign = -1;
417 }
418
419 unsigned long i, count = 0;
420 float abs_threshold = sign*threshold;
421
422 if ( verbose & VERB_DEBUG )
423 cout << "DEBUG img_find_features: threshold=" << threshold << " sign=" << sign << endl;
424
425 Bimage* pfeature = new Bimage(Integer, TSimple, p->sizeX(), p->sizeY(), p->sizeZ(), p->images());
426 pfeature->file_name() = p->file_name();
427 pfeature->sampling(p->sampling());
428 for ( i=0; i<p->images(); i++ ) pfeature->image[i] = p->image[i];
429
430 unsigned long datasize = p->data_size();
431
432 //Using a mask, all the features are grouped and numbered.
433 for ( i=0; i<datasize; i++ ) {
434 if ( (*pfeature)[i] == 0 ) {
435 if ( sign*(*p)[i] > abs_threshold ) {
436 count++;
437 img_assignAllMyNeighbors(p, (int *) pfeature->data_pointer(), i, count, threshold, sign, wrap);
438 }
439 }
440 }
441
442 pfeature->statistics();
443
444 if ( verbose & VERB_DEBUG )
445 cout << "DEBUG img_find_features: Finished with " << count << " features" << endl;
446
447 return pfeature;
448 }
449
455 double img_average_feature_size(Bimage* p)
456 {
457 unsigned long i, datasize = p->data_size();
458 long v, nr(0);
459 int nf = (int) (p->maximum() + 1);
460 int* f = new int[nf];
461 double a(0);
462
463 for ( i=0; i<nf; i++ ) f[i] = 0;
464
465 for ( i=0; i<datasize; i++ ) {
466 v = (long) (*p)[i];
467 if ( v > 0 ) f[v]++;
468 }
469
470 for ( i=0; i<nf; i++ ) if ( f[i] ) {
471 a += f[i];
472 nr++;
473 // cout << nr << tab << f[i] << endl;
474 }
475
476 if ( nr ) a /= nr;
477
478 if ( verbose & VERB_PROCESS ) {
479 cout << "Number of regions: " << nr << endl;
480 cout << "Average region size: " << a << endl << endl;
481 }
482
483 delete[] f;
484
485 return a;
486 }
487
488
489 int img_calc_kernel_limits(Bimage* p, unsigned long index, Vector3<long>& lo, Vector3<long>& hi, int wrap)
490 {
491 long n, i, x, y, z;
492
493 n = index / (p->sizeX()*p->sizeY()*p->sizeZ());
494 i = index - n*p->sizeX()*p->sizeY()*p->sizeZ();
495 z = i / (p->sizeX() * p->sizeY());
496 i -= z*p->sizeX()*p->sizeY();
497 y = i / p->sizeX();
498 x = i - y*p->sizeX();
499
500 //calculate the bounds on the kernel
501 lo[2] = z - 1;
502 lo[1] = y - 1;
503 lo[0] = x - 1;
504 hi[2] = z + 1;
505 hi[1] = y + 1;
506 hi[0] = x + 1;
507
508 if ( ! wrap ) {
509 if ( lo.z() < 0 ) lo[2] = 0;
510 if ( lo.y() < 0 ) lo[1] = 0;
511 if ( lo.x() < 0 ) lo[0] = 0;
512 if ( hi.z() >= p->sizeZ() ) hi[2] = p->sizeZ() - 1;
513 if ( hi.y() >= p->sizeY() ) hi[1] = p->sizeY() - 1;
514 if ( hi.x() >= p->sizeX() ) hi[0] = p->sizeX() - 1;
515 }
516
517 if ( verbose & VERB_DEBUG )
518 cout << "DEBUG img_calc_kernel_limits: lo=" << lo << " hi=" << hi << endl;
519
520 return 0;
521 }
522
543 int img_assignAllMyNeighbors(Bimage* p, int* feature_mask, unsigned long index,
544 int feature_number, float threshold, int sign, int wrap)
545 {
546 if ( verbose & VERB_DEBUG )
547 cout << "DEBUG img_assignAllMyNeighbors: Starting with feature " <<
548 feature_number << " index=" << index << endl;
549
550 if ( sign < 0 ) sign = -1;
551 else if ( sign > 0 ) sign = 1;
552 else {
553 sign = 1;
554 if ( threshold < p->average() ) sign = -1;
555 }
556
557 float abs_threshold = sign*threshold;
558 unsigned long i, j, n, x, y, z;
559 long xx, yy, zz;
560 Vector3<long> lo, hi;
561
562 // Set up two lists:
563 // First list is for voxels to loop through for checking
564 // Second list is for new voxels to be checked in a subsequent iteration
565 unsigned long number, new_number;
566 unsigned long list_size = 2*(p->sizeX() + p->sizeY())*p->sizeZ();
567 if ( p->sizeZ() > 1 ) list_size += 2*p->sizeX()*p->sizeY();
568 int* list = new int[list_size];
569 int* new_list = new int[list_size];
570
571 // Initialize the first item in the list
572 feature_mask[index] = feature_number;
573 number = 1;
574 list[0] = index;
575 n = index / (p->sizeX()*p->sizeY()*p->sizeZ());
576
577 // Find neighbors in shells around already found neighbors
578 while ( number > 0 ) {
579 if ( verbose & VERB_DEBUG )
580 cout << "DEBUG img_assignAllMyNeighbors: Feature " << feature_number << " list size=" << number << endl;
581 new_number = 0;
582 for ( i=0; i<number; i++ ) {
583 img_calc_kernel_limits(p, list[i], lo, hi, wrap);
584
585 // Loop through the kernel and construct the new list
586 for ( zz=lo.z(); zz<=hi.z(); zz++ ) {
587 z = zz;
588 if ( wrap ) {
589 if ( zz < 0 ) z = zz + (long)p->sizeZ();
590 if ( zz >= p->sizeZ() ) z = zz - p->sizeZ();
591 }
592 for ( yy=lo.y(); yy<=hi.y(); yy++ ) {
593 y = yy;
594 if ( wrap ) {
595 if ( yy < 0 ) y = yy + (long)p->sizeY();
596 if ( yy >= p->sizeY() ) y = yy - p->sizeY();
597 }
598 for ( xx=lo.x(); xx<=hi.x(); xx++ ) {
599 x = xx;
600 if ( wrap ) {
601 if ( xx < 0 ) x = xx + (long)p->sizeX();
602 if ( xx >= p->sizeX() ) x = xx - p->sizeX();
603 }
604 // cout << "x=%ld\ty=%ld\tz=%ld\n", x, y, z);
605 j = ((n*p->sizeZ() + z)*p->sizeY() + y)*p->sizeX() + x;
606 if ( (feature_mask[j] == 0) && (sign*(*p)[j] > abs_threshold) ) {
607 feature_mask[j] = feature_number;
608 new_list[new_number] = j;
609 new_number++;
610 if ( new_number >= list_size ) {
611 cerr << "Error: The list size exceeded its limit ("
612 << list_size << ")" << endl;
613 }
614 }
615 }
616 }
617 }
618 }
619 number = new_number;
620 for ( i=0; i<number; i++ ) list[i] = new_list[i];
621 }
622
623 delete[] list;
624 delete[] new_list;
625
626 if ( verbose & VERB_DEBUG )
627 cout << "DEBUG img_assignAllMyNeighbors: Ending with feature " << feature_number << endl;
628
629 return 0;
630 }
631
632
Bimage::change_type
void change_type(char letter)
Get the data type indicated by a single letter code.
Definition: Bimage.cpp:1438
Vector3::z
Type z()
Definition: Vector3.h:141
VERB_STATS
#define VERB_STATS
Definition: utilities.h:100
Bimage::sizeZ
void sizeZ(size_t nz)
Definition: Bimage.h:330
img_replace_maxima
int img_replace_maxima(Bimage *p, float threshold)
Replaces maxima above a threshold using local averages.
Definition: img_feature.cpp:39
img_average_feature_size
double img_average_feature_size(Bimage *p)
Calculates the average size of regions (features) in a level mask.
Definition: img_feature.cpp:455
utilities.h
Header file for general utilities.
img_mask.h
Header file for mask operation tools.
VERB_DEBUG
#define VERB_DEBUG
Definition: utilities.h:104
img_assignAllMyNeighbors
int img_assignAllMyNeighbors(Bimage *p, int *feature_mask, unsigned long index, int feature_number, float threshold, int sign, int wrap)
Finds all the pixels that are part of the same feature.
Definition: img_feature.cpp:543
Bimage::mask_by_threshold
Bimage * mask_by_threshold(double threshold)
Generates a mask based on an image at a given threshold.
Definition: Bimage_mask.cpp:93
img_extract_features
Bmarker * img_extract_features(Bimage *p, int extract_method, int target_num, float threshold)
Finds local minimums in a grey scale image and uses those as features.
Definition: img_feature.cpp:249
Float
Definition: Bimage.h:60
Bmarker
Definition: marker.h:21
add_item
char * add_item(char **list, unsigned long size)
Adds an item to a linked list.
Definition: linked_list.cpp:26
Vector3< int >
VERB_PROCESS
#define VERB_PROCESS
Definition: utilities.h:99
Bimage::truncate_to_min_max
int truncate_to_min_max(double minim, double maxim)
Truncates image data to a given minimum and maximum.
Definition: Bimage_rescale.cpp:200
Bimage::index
size_t index(size_t nx, size_t ny)
Definition: Bimage.h:334
Vector3::max
Type max()
Definition: Vector3.h:151
Bimage::average
double average(size_t cc, double xf, double yf, double zf, size_t nn, double iscale)
Averages in the xy plane when scaling is less than 1.
Definition: Bimage.cpp:1149
Bimage::statistics
size_t statistics()
Calculates the statistics for an image.
Definition: Bimage_stats.cpp:22
TSimple
Definition: Bimage.h:71
Bimage
General image parameter class.
Definition: Bimage.h:153
UCharacter
Definition: Bimage.h:52
linked_list.h
Header file for generalized linked list functions.
Bimage::maximum
double maximum()
Definition: Bimage.h:428
img_find_features
Bimage * img_find_features(Bimage *p, float threshold, int sign, int wrap)
Segments an image into contiguous regions (features).
Definition: img_feature.cpp:407
Bimage::channels
size_t channels()
Definition: Bimage.h:323
verbose
int verbose
img_replace_maxima2
int img_replace_maxima2(Bimage *p, float threshold)
Definition: img_feature.cpp:72
Bimage::sampling
void sampling(double s)
Definition: Bimage.h:412
markers_limit
long markers_limit(int target_num, int sign, Bmarker **set)
This method constricts a marker set to target_num points.
Definition: marker.cpp:887
Vector3::x
Type x()
Definition: Vector3.h:139
Bmarker::fom
float fom
Definition: marker.h:28
Bimage::file_name
void file_name(Bstring s)
Definition: Bimage.h:214
Bmarker::id
int id
Definition: marker.h:23
val
int val
Definition: jpeglib.h:956
Bimage::set
void set(size_t j, double v)
Sets a single value at the given index.
Definition: Bimage.cpp:915
Bimage::extract
Bimage * extract(size_t nn)
Extracts one sub-image into new image structure.
Definition: Bimage_extract.cpp:24
Bmarker::next
Bmarker * next
Definition: marker.h:22
write_img
int write_img(const char *filename, Bimage *p)
General driver function to write multiple image formats This is the only image writing function that ...
Definition: rwimg.cpp:251
Bimage::images
size_t images()
Definition: Bimage.h:410
Bimage::data_pointer
unsigned char * data_pointer()
Definition: Bimage.h:232
Bimage::data_size
size_t data_size()
Definition: Bimage.h:226
Integer
Definition: Bimage.h:57
Bstring
Definition: Bstring.h:25
Bimage::sizeX
void sizeX(size_t nx)
Definition: Bimage.h:328
Bmarker::img_num
int img_num
Definition: marker.h:24
Bimage::sizeY
void sizeY(size_t ny)
Definition: Bimage.h:329
Bmarker::err
Vector3< float > err
Definition: marker.h:26
Bmarker::loc
Vector3< float > loc
Definition: marker.h:25
img_calc_kernel_limits
int img_calc_kernel_limits(Bimage *p, unsigned long index, Vector3< long > &lo, Vector3< long > &hi, int wrap)
Definition: img_feature.cpp:489
img_feature.h
Header file for feature extraction tools.
VERB_FULL
#define VERB_FULL
Definition: utilities.h:101
VERB_LABEL
#define VERB_LABEL
Definition: utilities.h:98
Bimage::data_type
DataType data_type()
Definition: Bimage.h:303
Vector3::volume
double volume()
Definition: Vector3.h:207
Vector3::y
Type y()
Definition: Vector3.h:140
Bimage::minimum
double minimum()
Definition: Bimage.h:427
marker.h
Header file for image parameter functions.
Bmarker::sel
int sel
Definition: marker.h:29
tab
ostream & tab(ostream &out)
Definition: utilities.cpp:21
Bimage::image
Bsub_image * image
Definition: Bimage.h:184