00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include "PSCalib/SegGeometryMatrixV1.h"
00017 #include <sstream>
00018
00019
00020
00021
00022 #include <math.h>
00023 #include <iostream>
00024
00025
00026
00027
00028
00029 using namespace std;
00030
00031
00032
00033
00034 #include "PSCalib/CSPadCalibPars.h"
00035
00036
00037
00038
00039
00040 namespace PSCalib {
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064 bool matrix_pars( const std::string& segname
00065 , size_t& rows
00066 , size_t& cols
00067 , float& pix_size_rows
00068 , float& pix_size_cols)
00069 {
00070
00071
00072 if(segname.find("MTRX") == std::string::npos) {
00073 cout << "PSCalib::matrix_pars - this is not a MTRX segment, segname: " << segname << '\n';
00074 return false;
00075 }
00076
00077 std::string s(segname);
00078 for(unsigned i=0; i<s.size(); i++) {if(s[i]==':') s[i]=' ';}
00079
00080
00081 std::string pref;
00082 std::stringstream ss(s);
00083 ss >> pref >> rows >> cols >> pix_size_rows >> pix_size_cols;
00084
00085 return true;
00086 }
00087
00088
00089
00090
00091
00092 SegGeometryMatrixV1::SegGeometryMatrixV1 ( const size_t& rows
00093 , const size_t& cols
00094 , const float& pix_size_rows
00095 , const float& pix_size_cols
00096 , const float& pix_size_depth
00097 , const float& pix_scale_size
00098 )
00099 : PSCalib::SegGeometry()
00100 , ROWS(rows)
00101 , COLS(cols)
00102 , m_done_bits(0)
00103 , m_x_arr_um(0)
00104 , m_y_arr_um(0)
00105 , m_x_pix_coord_um(0)
00106 , m_y_pix_coord_um(0)
00107 , m_z_pix_coord_um(0)
00108 , m_x_pix_size_um(0)
00109 , m_y_pix_size_um(0)
00110 , m_z_pix_size_um(0)
00111 , m_pix_area_arr(0)
00112 , m_pix_mask_arr(0)
00113 {
00114
00115
00116 SIZE = ROWS * COLS;
00117 PIX_SIZE_ROWS = pix_size_rows;
00118 PIX_SIZE_COLS = pix_size_cols;
00119 PIX_SIZE_DEPTH = pix_size_depth;
00120 PIX_SCALE_SIZE = (pix_scale_size==SegGeometryMatrixV1::PIX_SCALE_SIZE_DEF)?
00121 min(PIX_SIZE_ROWS, PIX_SIZE_COLS) : pix_scale_size;
00122 UM_TO_PIX = 1./PIX_SCALE_SIZE;
00123
00124 IND_CORNER[0] = 0;
00125 IND_CORNER[1] = COLS-1;
00126 IND_CORNER[2] = (ROWS-1)*COLS;
00127 IND_CORNER[3] = ROWS*COLS-1;
00128
00129 ARR_SHAPE[0] = ROWS;
00130 ARR_SHAPE[1] = COLS;
00131
00132 make_pixel_coord_arrs();
00133 }
00134
00135
00136
00137
00138
00139 SegGeometryMatrixV1::~SegGeometryMatrixV1 ()
00140 {
00141 }
00142
00143
00144
00145
00146 void SegGeometryMatrixV1::make_pixel_coord_arrs()
00147 {
00148 if (m_x_arr_um) delete [] m_x_arr_um;
00149 if (m_y_arr_um) delete [] m_y_arr_um;
00150 if (m_x_pix_coord_um) delete [] m_x_pix_coord_um;
00151 if (m_y_pix_coord_um) delete [] m_y_pix_coord_um;
00152 if (m_z_pix_coord_um) delete [] m_z_pix_coord_um;
00153
00154 m_x_arr_um = new pixel_coord_t[ROWS];
00155 m_y_arr_um = new pixel_coord_t[COLS];
00156 m_x_pix_coord_um = new pixel_coord_t[SIZE];
00157 m_y_pix_coord_um = new pixel_coord_t[SIZE];
00158 m_z_pix_coord_um = new pixel_coord_t[SIZE];
00159
00160
00161 for (size_t r=0; r<ROWS; r++) m_x_arr_um[r] = r * PIX_SIZE_ROWS;
00162
00163
00164 for (size_t c=0; c<COLS; c++) m_y_arr_um[c] = c * PIX_SIZE_COLS;
00165
00166 size_t i = 0;
00167 for (size_t r=0; r<ROWS; r++) {
00168 for (size_t c=0; c<COLS; c++) {
00169 m_x_pix_coord_um [i] = m_x_arr_um [r];
00170 m_y_pix_coord_um [i++] = m_y_arr_um [c];
00171 }
00172 }
00173
00174 std::fill_n(m_z_pix_coord_um, int(SIZE), SegGeometry::pixel_coord_t(0));
00175 m_done_bits ^= 1;
00176 }
00177
00178
00179
00180 void SegGeometryMatrixV1::make_pixel_size_arrs()
00181 {
00182 if (m_done_bits & 2) return;
00183
00184 if (m_x_pix_size_um) delete [] m_x_pix_size_um;
00185 if (m_y_pix_size_um) delete [] m_y_pix_size_um;
00186 if (m_z_pix_size_um) delete [] m_z_pix_size_um;
00187 if (m_pix_area_arr ) delete [] m_pix_area_arr;
00188
00189 m_x_pix_size_um = new pixel_coord_t[SIZE];
00190 m_y_pix_size_um = new pixel_coord_t[SIZE];
00191 m_z_pix_size_um = new pixel_coord_t[SIZE];
00192 m_pix_area_arr = new pixel_area_t [SIZE];
00193
00194 std::fill_n(m_x_pix_size_um, int(SIZE), PIX_SIZE_COLS);
00195 std::fill_n(m_y_pix_size_um, int(SIZE), PIX_SIZE_ROWS);
00196 std::fill_n(m_z_pix_size_um, int(SIZE), PIX_SIZE_DEPTH);
00197 std::fill_n(m_pix_area_arr, int(SIZE), SegGeometry::pixel_area_t(1));
00198
00199 m_done_bits ^= 2;
00200 }
00201
00202
00203
00204 void SegGeometryMatrixV1::print_member_data()
00205 {
00206 cout << "SegGeometryMatrixV1::print_member_data():"
00207 << "\n ROWS " << ROWS
00208 << "\n COLS " << COLS
00209 << "\n PIX_SIZE_COLS " << PIX_SIZE_COLS
00210 << "\n PIX_SIZE_ROWS " << PIX_SIZE_ROWS
00211 << "\n PIX_SIZE_UM " << PIX_SCALE_SIZE
00212 << "\n UM_TO_PIX " << UM_TO_PIX
00213 << "\n";
00214 }
00215
00216
00217
00218 void SegGeometryMatrixV1::print_coord_arrs()
00219 {
00220 cout << "\nSegGeometryMatrixV1::print_coord_arrs\n";
00221
00222 cout << "m_x_arr_um:\n";
00223 for (unsigned counter=0, c=0; c<COLS; c++) {
00224 cout << " " << m_x_arr_um[c];
00225 if (++counter > 19) { counter=0; cout << "\n"; }
00226 }
00227 cout << "\n";
00228
00229 cout << "m_y_arr_um:\n";
00230 for (unsigned counter=0, r=0; r<ROWS; r++) {
00231 cout << " " << m_y_arr_um[r];
00232 if (++counter > 19) { counter=0; cout << "\n"; }
00233 }
00234 cout << "\n";
00235 }
00236
00237
00238
00239 void SegGeometryMatrixV1::print_min_max_coords()
00240 {
00241 cout << "Segment coordinate map limits:"
00242 << "\n xmin = " << pixel_coord_min (AXIS_X)
00243 << "\n xmax = " << pixel_coord_max (AXIS_X)
00244 << "\n ymin = " << pixel_coord_min (AXIS_Y)
00245 << "\n ymax = " << pixel_coord_max (AXIS_Y)
00246 << "\n zmin = " << pixel_coord_min (AXIS_Z)
00247 << "\n zmax = " << pixel_coord_max (AXIS_Z)
00248 << "\n";
00249 }
00250
00251
00252
00253
00254
00255 void SegGeometryMatrixV1::print_seg_info(const unsigned& pbits)
00256 {
00257 if (pbits & 1) print_member_data();
00258 if (pbits & 2) print_coord_arrs();
00259 if (pbits & 4) print_min_max_coords();
00260 }
00261
00262
00263
00264 const SegGeometry::pixel_area_t* SegGeometryMatrixV1::pixel_area_array()
00265 {
00266 make_pixel_size_arrs();
00267
00268 return m_pix_area_arr;
00269 }
00270
00271
00272
00273 const SegGeometry::pixel_coord_t* SegGeometryMatrixV1::pixel_size_array(AXIS axis)
00274 {
00275 make_pixel_size_arrs();
00276
00277 if (axis == AXIS_X) return m_x_pix_size_um;
00278 else if (axis == AXIS_Y) return m_y_pix_size_um;
00279 else if (axis == AXIS_Z) return m_z_pix_size_um;
00280 else return m_y_pix_size_um;
00281 }
00282
00283
00284
00285 const SegGeometry::pixel_coord_t* SegGeometryMatrixV1::pixel_coord_array (AXIS axis)
00286 {
00287 if (axis == AXIS_X) return m_x_pix_coord_um;
00288 else if (axis == AXIS_Y) return m_y_pix_coord_um;
00289 else if (axis == AXIS_Z) return m_z_pix_coord_um;
00290 else return m_x_pix_coord_um;
00291 }
00292
00293
00294
00295 const SegGeometry::pixel_coord_t SegGeometryMatrixV1::pixel_coord_min (AXIS axis)
00296 {
00297 const SegGeometry::pixel_coord_t* arr = pixel_coord_array (axis);
00298 SegGeometry::pixel_coord_t corner_coords[NCORNERS];
00299 for (size_t i=0; i<NCORNERS; ++i) { corner_coords[i] = arr[IND_CORNER[i]]; }
00300 return PSCalib::min_of_arr(corner_coords, NCORNERS);
00301 }
00302
00303
00304
00305 const SegGeometry::pixel_coord_t SegGeometryMatrixV1::pixel_coord_max (AXIS axis)
00306 {
00307 const SegGeometry::pixel_coord_t* arr = pixel_coord_array (axis);
00308 SegGeometry::pixel_coord_t corner_coords[NCORNERS];
00309 for (size_t i=0; i<NCORNERS; ++i) { corner_coords[i] = arr[IND_CORNER[i]]; }
00310 return PSCalib::max_of_arr(corner_coords, NCORNERS);
00311 }
00312
00313
00314
00315 const SegGeometry::pixel_mask_t* SegGeometryMatrixV1::pixel_mask_array(const unsigned& mbits)
00316 {
00317
00318
00319 if ( !(m_done_bits & 4)) {
00320 if (m_pix_mask_arr) delete [] m_pix_mask_arr;
00321 m_pix_mask_arr = new pixel_mask_t[SIZE];
00322 }
00323
00324 std::fill_n(m_pix_mask_arr, int(SIZE), SegGeometry::pixel_mask_t(1));
00325
00326 if(mbits & 1) {
00327
00328 for (size_t r=0; r<ROWS; r++) {
00329 m_pix_mask_arr[r*COLS] = 0;
00330 m_pix_mask_arr[r*COLS + COLS - 1] = 0;
00331 }
00332
00333 for (size_t c=0; c<COLS; c++) {
00334 m_pix_mask_arr[c] = 0;
00335 m_pix_mask_arr[(ROWS-1)*COLS + c] = 0;
00336 }
00337 }
00338
00339 m_done_bits ^= 4;
00340
00341 return m_pix_mask_arr;
00342 }
00343
00344
00345
00346
00347
00348
00349 }
00350
00351