Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Common/vtkBitArray.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    $RCSfile: vtkBitArray.h,v $
00005   Language:  C++
00006 
00007 
00008 Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen 
00009 All rights reserved.
00010 
00011 Redistribution and use in source and binary forms, with or without
00012 modification, are permitted provided that the following conditions are met:
00013 
00014  * Redistributions of source code must retain the above copyright notice,
00015    this list of conditions and the following disclaimer.
00016 
00017  * Redistributions in binary form must reproduce the above copyright notice,
00018    this list of conditions and the following disclaimer in the documentation
00019    and/or other materials provided with the distribution.
00020 
00021  * Neither name of Ken Martin, Will Schroeder, or Bill Lorensen nor the names
00022    of any contributors may be used to endorse or promote products derived
00023    from this software without specific prior written permission.
00024 
00025  * Modified source versions must be plainly marked as such, and must not be
00026    misrepresented as being the original software.
00027 
00028 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
00029 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00030 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00031 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
00032 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00033 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00034 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00035 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00036 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00037 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00038 
00039 =========================================================================*/
00052 #ifndef __vtkBitArray_h
00053 #define __vtkBitArray_h
00054 
00055 #include "vtkDataArray.h"
00056 
00057 class VTK_COMMON_EXPORT vtkBitArray : public vtkDataArray
00058 {
00059 public:
00060   static vtkBitArray *New();
00061   vtkTypeMacro(vtkBitArray,vtkDataArray);
00062   void PrintSelf(ostream& os, vtkIndent indent);
00063 
00066   int Allocate(const vtkIdType sz, const vtkIdType ext=1000);
00067 
00069   void Initialize();
00070 
00071   // satisfy vtkDataArray API
00072   vtkDataArray *MakeObject();
00073   int GetDataType() {return VTK_BIT;};
00074   
00076   void SetNumberOfTuples(const vtkIdType number);
00077 
00080   float *GetTuple(const vtkIdType i);
00081 
00083 
00084   void GetTuple(const vtkIdType i, float * tuple);
00085   void GetTuple(const vtkIdType i, double * tuple);
00087   
00089 
00090   void SetTuple(const vtkIdType i, const float * tuple);
00091   void SetTuple(const vtkIdType i, const double * tuple);
00093   
00095 
00097   void InsertTuple(const vtkIdType i, const float * tuple);
00098   void InsertTuple(const vtkIdType i, const double * tuple);
00100 
00102 
00104   vtkIdType InsertNextTuple(const float * tuple);
00105   vtkIdType InsertNextTuple(const double * tuple);
00107 
00112   void SetComponent(const vtkIdType i, const int j, const float c);
00113 
00115   void Squeeze();
00116 
00118   virtual void Resize(vtkIdType numTuples);
00119 
00121   int GetValue(const vtkIdType id);
00122 
00128   void SetNumberOfValues(const vtkIdType number);
00129 
00132   void SetValue(const vtkIdType id, const int value);
00133 
00135 
00136   void InsertValue(const vtkIdType id, const int i);
00137   vtkIdType InsertNextValue(const int i);
00139 
00143   virtual void InsertComponent(const vtkIdType i, const int j, const float c);
00144 
00146   unsigned char *GetPointer(const vtkIdType id) {return this->Array + id/8;}
00147 
00149 
00152   unsigned char *WritePointer(const vtkIdType id, const vtkIdType number);
00153   void *GetVoidPointer(const vtkIdType id)
00154     {return (void *)this->GetPointer(id);};
00156 
00158   void DeepCopy(vtkDataArray *da);
00159 
00161 
00167   void SetArray(unsigned char* array, vtkIdType size, int save);
00168   void SetVoidArray(void *array, vtkIdType size, int save) 
00169     {this->SetArray((unsigned char *)array, size, save);};
00171 
00172  
00173 protected:
00174   vtkBitArray(vtkIdType numComp=1);
00175   ~vtkBitArray();
00176 
00177   unsigned char *Array;   // pointer to data
00178   unsigned char *ResizeAndExtend(const vtkIdType sz);
00179     // function to resize data
00180 
00181   int TupleSize; //used for data conversion
00182   float *Tuple;
00183 
00184   int SaveUserArray;
00185 
00186 private:
00187   // hide superclass' DeepCopy() from the user and the compiler
00188   void DeepCopy(vtkDataArray &da) {this->vtkDataArray::DeepCopy(&da);}
00189   
00190 private:
00191   vtkBitArray(const vtkBitArray&);  // Not implemented.
00192   void operator=(const vtkBitArray&);  // Not implemented.
00193 };
00194 
00195 inline unsigned char *vtkBitArray::WritePointer(const vtkIdType id,
00196                                                 const vtkIdType number)
00197 {
00198   vtkIdType newSize=id+number;
00199   if ( newSize > this->Size )
00200     {
00201     this->ResizeAndExtend(newSize);
00202     }
00203   if ( (--newSize) > this->MaxId )
00204     {
00205     this->MaxId = newSize;
00206     }
00207   return this->Array + id/8;
00208 }
00209 
00210 inline void vtkBitArray::SetNumberOfValues(const vtkIdType number) 
00211 {
00212   this->Allocate(number);
00213   this->MaxId = number - 1;
00214 }
00215 
00216 inline void vtkBitArray::SetValue(const vtkIdType id, const int value) 
00217 {
00218   if (value)
00219     {
00220     this->Array[id/8] |= (0x80 >> id%8);
00221     }
00222   else
00223     {
00224     this->Array[id/8] &= (~(0x80 >> id%8));
00225     }
00226 }
00227 
00228 inline void vtkBitArray::InsertValue(const vtkIdType id, const int i)
00229 {
00230   if ( id >= this->Size )
00231     {
00232     this->ResizeAndExtend(id+1);
00233     }
00234   if (i)
00235     {
00236     this->Array[id/8] |= (0x80 >> id%8);
00237     }
00238   else
00239     {
00240     this->Array[id/8] &= (~(0x80 >> id%8));
00241     }
00242   if ( id > this->MaxId )
00243     {
00244     this->MaxId = id;
00245     }
00246 }
00247 
00248 inline vtkIdType vtkBitArray::InsertNextValue(const int i)
00249 {
00250   this->InsertValue (++this->MaxId,i); return this->MaxId;
00251 }
00252 
00253 inline void vtkBitArray::Squeeze() {this->ResizeAndExtend (this->MaxId+1);}
00254 
00255 #endif
00256 

Generated on Thu Mar 28 14:19:14 2002 for VTK by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001