Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

volume_data.cpp

Go to the documentation of this file.
00001 // Copyright (C) 2005-2008 Washington University in St Louis, Baylor College of Medicine.  All rights reserved
00002 // Author:        Sasakthi S. Abeysinghe (sasakthi@gmail.com)
00003 // Description:   Stores information of a density volume
00004 
00005 #include "volume_data.h"
00006 
00007 using namespace wustl_mm::SkeletonMaker;
00008 
00009                 VolumeData::VolumeData(EMData* em)
00010                 {
00011                         this->emdata = em;
00012                         owns_emdata = false;
00013                 }
00014 
00015                 VolumeData::VolumeData(int sizeX, int sizeY, int sizeZ) {
00016                         InitializeVolumeData(sizeX, sizeY, sizeZ, 1, 1, 1, 0, 0, 0, true, 0);
00017                 }
00018 
00019                 VolumeData::VolumeData(int sizeX, int sizeY, int sizeZ, float val) {
00020                         InitializeVolumeData(sizeX, sizeY, sizeZ, 1, 1, 1, 0, 0, 0, true, val);
00021                 }
00022 
00023                 VolumeData::VolumeData(int sizeX, int sizeY, int sizeZ, int offsetX, int offsetY, int offsetZ, VolumeData * data) {
00024                         InitializeVolumeData(sizeX, sizeY, sizeZ, data->GetSpacingX(), data->GetSpacingY(), data->GetSpacingZ(), data->GetOriginX(), data->GetOriginY(), data->GetOriginZ(), false, 0);
00025                         float value;
00026                         for ( int k = offsetZ; k < sizeZ + offsetZ; k++) {
00027                                 for (int j = offsetY; j < sizeY + offsetY; j++ ) {
00028                                         for (int i = offsetX; i < sizeX + offsetX; i++) {
00029                                                 value = data->GetDataAt(i,j,k);
00030                                                 SetDataAt(i-offsetX,j-offsetY,k-offsetZ, value);
00031                                         }
00032                                 }
00033                         }
00034                 }
00035 
00036                 VolumeData::VolumeData(VolumeData& obj)
00037                 {
00038                         emdata = new EMData( *obj.get_emdata() );
00039                         owns_emdata = true;
00040                         //SetSize( obj.GetSizeX(), obj.GetSizeY(), obj.GetSizeZ() );
00041                         //SetSpacing( obj.GetSpacingX(), obj.GetSpacingY(), obj.GetSpacingZ() );
00042                         //SetOrigin( obj.GetOriginX(), GetOriginY(), obj.GetOriginZ() );
00043                 }
00044                 VolumeData::~VolumeData() {
00045                         if (owns_emdata)
00046                                 delete emdata;
00047                 }
00048 
00049                 void VolumeData::InitializeVolumeData(int sizeX, int sizeY, int sizeZ, float spacingX, float spacingY, float spacingZ, float originX, float originY, float originZ, bool initializeData, float val) {
00050                         emdata = new EMData(sizeX, sizeY, sizeZ);
00051                         owns_emdata = true;
00052                         //SetSize(sizeX, sizeY, sizeZ);
00053                         SetSpacing(spacingX, spacingY, spacingZ);
00054                         SetOrigin(originX, originY, originZ);
00055                         if(initializeData) {
00056                                 emdata->to_value(val);
00057                         }
00058                 }
00059 
00060                 int VolumeData::GetSize(int dimension) {
00061                         int ret = 0;
00062                         switch (dimension)
00063                         {
00064                                 case 0: ret = GetSizeX();
00065                                         break;
00066                                 case 1: ret = GetSizeY();
00067                                         break;
00068                                 case 2: ret = GetSizeZ();
00069                                         break;
00070                                 default:
00071                                         throw InvalidParameterException("VolumeData::GetSize requires an argument of 0, 1, or 2");
00072                         }
00073 
00074                         return ret;
00075 
00076                 }
00077 
00078                 int VolumeData::GetSizeX() {
00079                         return emdata->get_xsize();
00080                 }
00081 
00082                 int VolumeData::GetSizeY() {
00083                         return emdata->get_ysize();
00084                 }
00085 
00086                 int VolumeData::GetSizeZ() {
00087                         return emdata->get_zsize();
00088                 }
00089 
00090                 float VolumeData::GetSpacing(int dimension) {
00091                         float ret = 0;
00092                         switch (dimension)
00093                         {
00094                                 case 0: ret = GetSpacingX();
00095                                         break;
00096                                 case 1: ret = GetSpacingY();
00097                                         break;
00098                                 case 2: ret = GetSpacingZ();
00099                                         break;
00100                                 default:
00101                                         throw InvalidParameterException("VolumeData::GetSpacing requires an argument of 0, 1, or 2");
00102                         }
00103 
00104                         return ret;
00105                 }
00106 
00107                 float VolumeData::GetSpacingX() {
00108                         return emdata->get_attr("apix_x");
00109                 }
00110 
00111                 float VolumeData::GetSpacingY() {
00112                         return emdata->get_attr("apix_y");
00113                 }
00114 
00115                 float VolumeData::GetSpacingZ() {
00116                         return emdata->get_attr("apix_y");
00117                 }
00118 
00119                 float VolumeData::GetOrigin(int dimension) {
00120                         float ret = 0;
00121                         switch (dimension)
00122                         {
00123                                 case 0: ret = GetOriginX();
00124                                         break;
00125                                 case 1: ret = GetOriginY();
00126                                         break;
00127                                 case 2: ret = GetOriginZ();
00128                                         break;
00129                                 default:
00130                                         throw InvalidParameterException("VolumeData::GetOrigin requires an argument of 0, 1, or 2");
00131                         }
00132 
00133                         return ret;
00134                 }
00135 
00136                 float VolumeData::GetOriginX() {
00137                         return emdata->get_attr("origin_x");
00138                 }
00139 
00140                 float VolumeData::GetOriginY() {
00141                         return emdata->get_attr("origin_y");
00142                 }
00143 
00144                 float VolumeData::GetOriginZ() {
00145                         return emdata->get_attr("origin_z");
00146                 }
00147 
00148 
00149                 float VolumeData::GetDataAt(int x, int y, int z) {
00150                         return this->emdata->get_value_at(x, y, z);
00151                 }
00152 
00153                 float VolumeData::GetDataAt(int index) {
00154                         //TODO: This may be a problem because EMAN2 and Gorgon do indexing differently --> see if this causes problems
00155                         return emdata->get_value_at(index);
00156                 }
00157 
00158                 int VolumeData::GetIndex(int x, int y, int z) {
00159                         return (x + y * GetSizeX() + z * GetSizeX() * GetSizeY());
00160                 }
00161 
00162                 int VolumeData::GetMaxIndex() {
00163                         return GetSizeX() * GetSizeY() * GetSizeZ();
00164                 }
00165 
00166                 EMData * VolumeData::get_emdata() //eman2
00167                 {
00168                         return emdata;
00169                 }
00170 
00171                 void VolumeData::SetSpacing(float spacingX, float spacingY, float spacingZ) {
00172                         emdata->set_attr("apix_x", spacingX);
00173                         emdata->set_attr("apix_y", spacingY);
00174                         emdata->set_attr("apix_z", spacingZ);
00175                 }
00176 
00177                 void VolumeData::SetOrigin(float originX, float originY, float originZ) {
00178                         emdata->set_attr("origin_x", originX);
00179                         emdata->set_attr("origin_y", originY);
00180                         emdata->set_attr("origin_z", originZ);
00181                 }
00182 
00183 
00184                 void VolumeData::SetSize(int sizeX, int sizeY, int sizeZ) {
00185                         emdata->set_size(sizeX, sizeY, sizeZ);
00186                 }
00187 
00188                 void VolumeData::SetDataAt(int x, int y, int z, float value) {
00189                         emdata->set_value_at(x, y, z, value);
00190                 }
00191 
00192                 void VolumeData::SetDataAt(int index, float value) {
00193                         //TODO: This may be a problem because EMAN2 and Gorgon do indexing differently --> see if this causes problems
00194                         emdata->get_data()[index] = value;
00195                 }
00196                 void VolumeData::Pad(int padBy, double padValue) {
00197 
00198                         int sizex = GetSizeX();
00199                         int sizey = GetSizeY();
00200                         int sizez = GetSizeZ();
00201                         int newSizeX = sizex + 2*padBy;
00202                         int newSizeY = sizey + 2*padBy;
00203                         int newSizeZ = sizez + 2*padBy;
00204 
00205                         // Method 1: Using get_clip ===========================================================
00206 //                      Region reg(0, 0, 0, newSizeX, newSizeY, newSizeZ);
00207 //                      EMData * new_emdata = emdata->get_clip(reg); //Extends the area x > sizex, y > sizey, z > sizez but does not translate (0,0,0)
00208 //                      new_emdata->translate(padBy,padBy,padBy); //We want equal padding on each side
00209 //
00210 //                      for(int z = 0; z < newSizeZ; z++)
00211 //                              for(int y = 0; y < newSizeY; y++)
00212 //                                      for(int x = 0; x < newSizeX; x++)
00213 //                                              if ((x < padBy) || (y < padBy) || (z < padBy) || (x >= padBy + sizex) || (y >= padBy + sizey) || (z >= padBy + sizez))
00214 //                                                      new_emdata->set_value_at(x, y, z, padValue);
00215 //
00216 //                      if (this->owns_emdata)
00217 //                              this->emdata->free_memory();
00218 //                      this->emdata = new_emdata;
00219 
00220                         // Method 2: making a copy =============================================================
00221                         float * newData = (float*) malloc ( newSizeX * newSizeY * newSizeZ * sizeof(float) );
00222                         double value;
00223 
00224                         for(int z = 0; z < newSizeZ; z++) {
00225                                 for(int y = 0; y < newSizeY; y++) {
00226                                         for(int x = 0; x < newSizeX; x++) {
00227                                                 if ((x < padBy) || (y < padBy) || (z < padBy) || (x >= padBy + sizex) || (y >= padBy + sizey) || (z >= padBy + sizez)) {
00228                                                         value = padValue;
00229                                                 } else {
00230                                                         value = GetDataAt(x-padBy, y-padBy, z-padBy);
00231                                                 }
00232 
00233                                                 newData[x + y * newSizeX + z * newSizeX * newSizeY] = static_cast<float>(value); //eman2
00234                                         }
00235                                 }
00236                         }
00237 
00238                         SetSize(newSizeX, newSizeY, newSizeZ);
00239                         emdata->set_data(newData, newSizeX, newSizeY, newSizeZ);
00240                         //free(data); //I think this is handled by set_data
00241 
00242                         // Method 3: doing in-place resize =====================================================
00243 //                      emdata->set_size(newSizeX, newSizeY, newSizeZ);
00244 //                      double val;
00245 //                      for (int k = newSizeZ - 1; k >= 0; k--)
00246 //                              for (int j = newSizeY - 1; k >= 0; j--)
00247 //                                      for (int i = newSizeX - 1; k >=0; k--)
00248 //                                      {
00249 //                                              if ( i < padBy || i >= sizex+padBy || j < padBy || j >= sizey+padBy || k < padBy || k >= sizez+padBy)
00250 //                                                      emdata->set_value_at(i,j,k, padValue);
00251 //                                              else
00252 //                                              {
00253 //                                                      val = emdata->get_value_at(i-padBy, j-padBy, k-padBy);
00254 //                                                      emdata->set_value_at(i,j,k, float(val));
00255 //                                              }
00256 //                                      }
00257                 }

Generated on Tue Jun 11 13:40:45 2013 for EMAN2 by  doxygen 1.3.9.1