33 #ifndef vtkOpenGLContextDevice2DPrivate_h
34 #define vtkOpenGLContextDevice2DPrivate_h
101 return this->first == other.first;
117 return std::find(this->
Cache.begin(), this->Cache.end(),
key) != this->
Cache.end();
135 typename std::list<CacheElement>::iterator it;
136 for (it = this->
Cache.begin(); it != this->Cache.end(); ++it)
138 it->second.Texture->ReleaseGraphicsResources(window);
152 if (this->
Cache.size() >= this->MaxSize)
154 this->
Cache.pop_back();
157 return this->
Cache.begin()->second;
177 typename std::list<CacheElement>::iterator it =
179 if (it != this->Cache.end())
187 return this->AddCacheData(
key, cacheData);
193 template <
class StringType>
210 vtkTypeUInt32 hash =
static_cast<vtkTypeUInt32
>(id);
214 assert(
"Hash is really a uint32" &&
static_cast<size_t>(hash) ==
id);
238 this->
Color.
Set(
static_cast<unsigned char>(color[0] * 255),
239 static_cast<unsigned char>(
color[1] * 255),
static_cast<unsigned char>(
color[2] * 255),
240 static_cast<unsigned char>(textProperty->
GetOpacity() * 255));
328 ::glDrawBuffers(1, bufs);
338 float* texCoord =
new float[2 * n];
344 for (
int i = 0; i < n; ++i)
346 minX = fptr[0] < minX ? fptr[0] : minX;
347 maxX = fptr[0] > maxX ? fptr[0] : maxX;
348 minY = fptr[1] < minY ? fptr[1] : minY;
349 maxY = fptr[1] > maxY ? fptr[1] : maxY;
357 (textureBounds[1] - textureBounds[0]) ? textureBounds[1] - textureBounds[0] : 1.;
359 (textureBounds[3] - textureBounds[2]) ? textureBounds[3] - textureBounds[2] : 1.;
360 for (
int i = 0; i < n; ++i)
362 texCoord[i * 2] = (fptr[0] - minX) / rangeX;
363 texCoord[i * 2 + 1] = (fptr[1] - minY) / rangeY;
369 float rangeX = (maxX - minX) ? maxX - minX : 1.f;
370 float rangeY = (maxY - minY) ? maxY - minY : 1.f;
371 for (
int i = 0; i < n; ++i)
373 texCoord[i * 2] = (fptr[0] - minX) / rangeX;
374 texCoord[i * 2 + 1] = (fptr[1] - minY) / rangeY;
384 for (
int i = 0; i < 2; ++i)
386 while (pow2[i] <
size[i])
398 vtkGenericWarningMacro(
"Invalid image format: expected unsigned char.");
401 int bytesPerPixel =
image->GetNumberOfScalarComponents();
406 for (
int i = 0; i < 2; ++i)
408 texCoords[i] =
size[i] / float(newImg[i]);
411 unsigned char* dataPtr =
new unsigned char[newImg[0] * newImg[1] * bytesPerPixel];
412 unsigned char* origPtr =
static_cast<unsigned char*
>(
image->GetScalarPointer());
414 for (
int i = 0; i < newImg[0]; ++i)
416 for (
int j = 0; j < newImg[1]; ++j)
418 for (
int k = 0; k < bytesPerPixel; ++k)
422 dataPtr[i * bytesPerPixel + j * newImg[0] * bytesPerPixel + k] =
423 origPtr[i * bytesPerPixel + j *
size[0] * bytesPerPixel + k];
427 dataPtr[i * bytesPerPixel + j * newImg[0] * bytesPerPixel + k] = k == 3 ? 0 : 255;
434 GLint glFormat = bytesPerPixel == 3 ? GL_RGB : GL_RGBA;
435 GLint glInternalFormat = bytesPerPixel == 3 ? GL_RGB8 : GL_RGBA8;
437 glGenTextures(1, &tmpIndex);
438 glBindTexture(GL_TEXTURE_2D, tmpIndex);
440 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
441 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
442 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
443 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
445 glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, newImg[0], newImg[1], 0, glFormat,
446 GL_UNSIGNED_BYTE,
static_cast<const GLvoid*
>(dataPtr));
455 cout <<
"Error = not an unsigned char..." << endl;
458 int bytesPerPixel =
image->GetNumberOfScalarComponents();
462 unsigned char* dataPtr =
static_cast<unsigned char*
>(
image->GetScalarPointer());
464 GLint glFormat = bytesPerPixel == 3 ? GL_RGB : GL_RGBA;
465 GLint glInternalFormat = bytesPerPixel == 3 ? GL_RGB8 : GL_RGBA8;
467 glGenTextures(1, &tmpIndex);
468 glBindTexture(GL_TEXTURE_2D, tmpIndex);
470 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
471 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
472 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
473 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
475 glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat,
size[0],
size[1], 0, glFormat,
476 GL_UNSIGNED_BYTE,
static_cast<const GLvoid*
>(dataPtr));
545 this->cache =
new PolyDataCache();
557 this->Colors = colors;
563 this->DrawLines(polyData, scalarMode, x, y,
scale);
567 this->DrawPolygons(polyData, scalarMode, x, y,
scale);
578 struct PolyDataCacheItem
582 std::vector<float> PolyTri;
586 std::vector<float> Lines;
595 std::map<vtkPolyData*, PolyDataCacheItem*>::iterator itPrev = this->PrevFrameCache.begin();
596 for (; itPrev != this->PrevFrameCache.end(); ++itPrev)
598 delete itPrev->second;
601 std::map<vtkPolyData*, PolyDataCacheItem*>::iterator it = this->CurrentFrameCache.begin();
602 for (; it != this->CurrentFrameCache.end(); ++it)
610 PolyDataCacheItem* cacheItem = this->CurrentFrameCache[
key];
611 if (cacheItem ==
nullptr)
613 cacheItem = this->PrevFrameCache[
key];
614 if (cacheItem ==
nullptr)
616 cacheItem =
new PolyDataCacheItem();
623 this->PrevFrameCache.erase(
key);
627 this->CurrentFrameCache[
key] = cacheItem;
638 std::map<vtkPolyData*, PolyDataCacheItem*>::iterator itPrev = this->PrevFrameCache.begin();
639 for (; itPrev != this->PrevFrameCache.end(); ++itPrev)
641 delete itPrev->second;
645 this->PrevFrameCache.clear();
648 std::swap(this->PrevFrameCache, this->CurrentFrameCache);
653 std::map<vtkPolyData*, PolyDataCacheItem*> PrevFrameCache;
654 std::map<vtkPolyData*, PolyDataCacheItem*> CurrentFrameCache;
661 float const posX,
float const posY,
float const scale,
vtkIdType cellId,
int scalarMode)
663 this->CellPoints.reserve(this->NumPointsCell * 2);
665 for (
int i = 0; i < this->NumPointsCell; i++)
671 float const x =
static_cast<float>(
point[0]) + posX;
672 float const y =
static_cast<float>(
point[1]) + posY;
673 this->CellPoints.push_back(x *
scale);
674 this->CellPoints.push_back(y *
scale);
681 mappedColorId = this->PointIds[i];
684 mappedColorId = cellId;
687 std::cerr <<
"Scalar mode not supported!" << std::endl;
691 this->CellColors->
SetTuple(i, mappedColorId, this->Colors);
701 vtkPolyData* polyData,
int scalarMode,
float const x,
float const y,
float const scale)
703 PolyDataCacheItem* cacheItem = this->cache->GetCacheEntry(polyData);
705 if (polyData->
GetMTime() > cacheItem->LinesLoadingTime)
708 cacheItem->Lines.clear();
709 cacheItem->LineColors->Reset();
713 cacheItem->Lines.reserve(numVertices * 2);
715 cacheItem->LineColors->SetNumberOfTuples(numVertices);
729 for (
int i = 0; i < actualNumPointsCell - 1; ++i)
731 this->NumPointsCell = 2;
734 this->MapCurrentCell(x, y,
scale, cellId, scalarMode);
737 for (
int j = 0; j < this->NumPointsCell; j++)
739 cacheItem->Lines.push_back(this->CellPoints[2 * j]);
740 cacheItem->Lines.push_back(this->CellPoints[2 * j + 1]);
742 double* color4 = this->CellColors->
GetTuple(j);
743 cacheItem->LineColors->InsertTuple4(
744 vertOffset + j, color4[0], color4[1], color4[2], color4[3]);
747 vertOffset += this->NumPointsCell;
748 this->CellColors->
Reset();
749 this->CellPoints.clear();
754 cacheItem->LinesLoadingTime.Modified();
758 if (cacheItem->Lines.size() > 0)
760 this->Device->
DrawLines(&cacheItem->Lines[0],
static_cast<int>(cacheItem->Lines.size() / 2),
761 static_cast<unsigned char*
>(cacheItem->LineColors->GetVoidPointer(0)),
762 cacheItem->LineColors->GetNumberOfComponents());
783 numTriVert += 3 * (this->NumPointsCell - 2);
796 vtkPolyData* polyData,
int scalarMode,
float const x,
float const y,
float const scale)
798 PolyDataCacheItem* cacheItem = this->cache->GetCacheEntry(polyData);
800 if (polyData->
GetMTime() > cacheItem->PolygonsLoadingTime)
802 cacheItem->PolyTri.clear();
803 cacheItem->PolyColors->Reset();
806 vtkIdType const totalTriVert = this->GetCountTriangleVertices(polyData);
807 cacheItem->PolyTri.reserve(totalTriVert * 2);
809 cacheItem->PolyColors->SetNumberOfTuples(totalTriVert);
829 this->MapCurrentCell(x, y,
scale, cellId, scalarMode);
832 for (
int i = 0; i < this->NumPointsCell - 2; i++)
834 cacheItem->PolyTri.push_back(this->CellPoints[0]);
835 cacheItem->PolyTri.push_back(this->CellPoints[1]);
836 cacheItem->PolyTri.push_back(this->CellPoints[i * 2 + 2]);
837 cacheItem->PolyTri.push_back(this->CellPoints[i * 2 + 3]);
838 cacheItem->PolyTri.push_back(this->CellPoints[i * 2 + 4]);
839 cacheItem->PolyTri.push_back(this->CellPoints[i * 2 + 5]);
842 vtkIdType const triangOffset = vertOffset + 3 * i;
843 double* color4 = this->CellColors->
GetTuple(0);
844 cacheItem->PolyColors->InsertTuple4(
845 triangOffset, color4[0], color4[1], color4[2], color4[3]);
847 color4 = this->CellColors->
GetTuple(i + 1);
848 cacheItem->PolyColors->InsertTuple4(
849 triangOffset + 1, color4[0], color4[1], color4[2], color4[3]);
851 color4 = this->CellColors->
GetTuple(i + 2);
852 cacheItem->PolyColors->InsertTuple4(
853 triangOffset + 2, color4[0], color4[1], color4[2], color4[3]);
856 vertOffset += 3 * (this->NumPointsCell - 2);
857 this->CellColors->
Reset();
858 this->CellPoints.clear();
862 cacheItem->PolygonsLoadingTime.Modified();
866 if (cacheItem->PolyTri.size() > 0)
869 static_cast<unsigned char*
>(cacheItem->PolyColors->GetVoidPointer(0)), 4);
884 std::vector<float> CellPoints;
888 PolyDataCache* cache;
void SetTuple(vtkIdType tupleIdx, const float *tuple) override
Set the data tuple at tupleIdx.
void GetTuple(vtkIdType tupleIdx, double *tuple) override
Get the data tuple at tupleIdx by filling in a user-provided array, Make sure that your array is larg...
int GetNumberOfComponents() const
void Reset()
Reset to an empty state, without freeing any memory.
Efficient cell iterator for vtkDataSet topologies.
virtual vtkIdType GetCellId()=0
Get the id of the current cell.
void GoToNextCell()
Increment to next cell.
virtual bool IsDoneWithTraversal()=0
Returns false while the iterator is valid.
vtkIdType GetNumberOfPoints()
Return the number of points in the cell.
vtkIdList * GetPointIds()
Return the list of point ids defining the cell.
void Set(const T &red, const T &green, const T &blue)
Set the red, green and blue components of the color.
double * GetBounds()
Return a pointer to the geometry bounding box in the form (xmin,xmax, ymin,ymax, zmin,...
int GetCellType() override
Return the type of cell.
void SetNumberOfComponents(int num) override
Set/Get the dimension (n) of the components.
void SetNumberOfTuples(vtkIdType number) override
Set the number of tuples (a component group) in the array.
vtkIdType * GetPointer(const vtkIdType i)
Get a pointer to a particular data index.
void SetInputData(vtkDataObject *)
Assign a data object as input.
topologically and geometrically regular array of data
virtual void Delete()
Delete a VTK object.
void Draw(int cellType, vtkPolyData *polyData, vtkPoints *points, float x, float y, float scale, int scalarMode, vtkUnsignedCharArray *colors=nullptr)
Draw primitives as specified by cellType.
CellArrayHelper(vtkOpenGLContextDevice2D *device)
vtkVector2i FindPowerOfTwo(const vtkVector2i &size)
void SaveGLState(vtkOpenGLState *ostate, bool colorBuffer=false)
unsigned int TextureProperties
void RestoreGLState(vtkOpenGLState *ostate, bool colorBuffer=false)
vtkTexture * SpriteTexture
vtkTextureImageCache< UTF16TextPropertyKey > TextTextureCache
Cache for text images.
vtkTextureImageCache< UTF8TextPropertyKey > MathTextTextureCache
float * TexCoords(float *f, int n)
GLuint TextureFromImage(vtkImageData *image, vtkVector2f &texCoords)
GLuint TextureFromImage(vtkImageData *image)
GLfloat SavedClearColor[4]
Class for drawing 2D primitives using OpenGL 1.1+.
void CoreDrawTriangles(std::vector< float > &tverts, unsigned char *colors=nullptr, int numComp=0)
void DrawLines(float *f, int n, unsigned char *colors=nullptr, int nc_comps=0) override
Draw lines using the points - memory layout is as follows: l1p1,l1p2,l2p1,l2p2...
void vtkglGetIntegerv(unsigned int pname, int *params)
bool GetEnumState(unsigned int name)
void vtkglGetFloatv(unsigned int pname, float *params)
void vtkglClearColor(float red, float green, float blue, float alpha)
void SetEnumState(unsigned int name, bool value)
vtkCellIterator * NewCellIterator() override
Return an iterator that traverses the cells in this data set.
represent and manipulate 3D points
double * GetPoint(vtkIdType id)
Return a pointer to a double point x[3] for a specific id.
concrete dataset represents vertices, lines, polygons, and triangle strips
vtkMTimeType GetMTime() override
Get MTime which also considers its cell array MTime.
vtkCell * GetCell(vtkIdType cellId) override
Get cell with cellId such that: 0 <= cellId < NumberOfCells.
vtkIdType GetNumberOfCells() override
Standard vtkDataSet interface.
static vtkSmartPointer< T > New()
Create an instance of a VTK object.
represent text properties.
virtual int GetVerticalJustification()
virtual double GetOpacity()
virtual int GetFontSize()
virtual double * GetColor()
virtual int GetJustification()
bool IsKeyInCache(const Key &key) const
Search the cache list to see if a given key already exists.
std::list< CacheElement > Cache
List of a pair of key and cache data.
void ReleaseGraphicsResources(vtkWindow *window)
Release all the OpenGL Pixel Buffer Object(PBO) associated with the textures of the cache list.
vtkTextureImageCache()
Construct a texture image cache with a maximum number of texture of 50.
size_t MaxSize
Maximum size the cache list can be.
CacheData & AddCacheData(const Key &key, const CacheData &cacheData)
Add a new cache entry into the cache list.
CacheData & GetCacheData(const Key &key)
Return the cache associated to a key.
handles properties associated with a texture map
vtkImageData * GetInput()
Get the input as a vtkImageData object.
record modification and/or execution time
dynamic, self-adjusting array of unsigned char
Some derived classes for the different vectors commonly used.
window superclass for vtkRenderWindow
TextPropertyKey(vtkTextProperty *textProperty, const StringType &text, int dpi)
Creates a TextPropertyKey.
vtkTypeUInt32 TextPropertyId
static vtkTypeUInt32 GetIdFromTextProperty(vtkTextProperty *tprop)
Transform a text property into an unsigned long.
bool operator==(const TextPropertyKey &other) const
Compares two TextPropertyKeys with each other.
vtkSmartPointer< vtkImageData > ImageData
vtkTextRenderer::Metrics Metrics
vtkSmartPointer< vtkTexture > Texture
CacheElement associates a unique key to some cache.
CacheElement(const Key &key, const CacheData &cacheData)
CacheElement(const Key &key)
bool operator==(const CacheElement &other) const
#define VTK_SCALAR_MODE_USE_POINT_DATA
#define VTK_SCALAR_MODE_USE_CELL_DATA
TextPropertyKey< vtkUnicodeString > UTF16TextPropertyKey
TextPropertyKey< vtkStdString > UTF8TextPropertyKey
#define VTK_UNSIGNED_CHAR