#include <cctwdatachunk.h>

Inheritance diagram for CctwDataChunk:

Collaboration diagram for CctwDataChunk:

Public Slots
int	allocateData ()

int	allocateWeights ()

int	deallocateData ()

int	deallocateWeights ()

int	detachData ()

int	detachWeights ()

bool	dataAllocated () const

bool	weightsAllocated () const

CctwChunkedData::MergeDataType	data (int lx, int ly, int lz)

CctwChunkedData::MergeDataType	weight (int lx, int ly, int lz)

void	setData (int lx, int ly, int lz, CctwChunkedData::MergeDataType val)

void	setWeight (int lx, int ly, int lz, CctwChunkedData::MergeDataType val)

int	pixelOffset (int lx, int ly, int lz)

CctwChunkedData::MergeDataType *	dataPointer ()

CctwChunkedData::MergeDataType *	weightsPointer ()

CctwIntVector3D	chunkStart ()

void	resetChunkStart ()

CctwIntVector3D	chunkSize ()

void	setChunkSize (CctwIntVector3D size)

void	clearDependencies ()

void	addDependency (int dep)

void	sortDependencies ()

int	dependencyCount () const

int	dependency (int n) const

void	reportDependencies ()

int	index () const

void	mergeChunk (CctwDataChunk *c)

void	clearMergeCounters ()

void	incMergeCounters ()

int	mergeCount ()

bool	popMergeData (CctwChunkedData::MergeDataType data, CctwChunkedData::MergeDataType weights)

void	pushMergeData (CctwChunkedData::MergeDataType data, CctwChunkedData::MergeDataType weights)

void	normalizeChunk ()

static void	resetAllocationLimits (int nmax)

static int	maxAllocated ()

void	setBuffer (void *buffer)

void	mergeData (CctwChunkedData::MergeDataType id, CctwChunkedData::MergeDataType iw, int n)

static int	allocatedChunkCount ()

Public Slots inherited from CctwObject
virtual void	printLine (QString line)

virtual void	printMessage (QString msg, QDateTime dt=QDateTime::currentDateTime())

virtual QString	settingsScript ()

QString	scriptValueLiteral (QVariant v)

Public Member Functions
	CctwDataChunk (CctwChunkedData data, int index, QString name, QObject parent)

virtual	~CctwDataChunk ()

Public Member Functions inherited from CctwObject
	CctwObject (QString name, QObject *parent=0)

virtual void	writeSettings (QSettings *set, QString section)

virtual void	readSettings (QSettings *set, QString section)

Private Member Functions
CctwChunkedData::MergeDataType *	allocateBuffer ()

void	releaseBuffer (CctwChunkedData::MergeDataType *)

CctwIntVector3D	calculateChunkStart ()

CctwIntVector3D	calculateChunkSize ()

Private Attributes
CctwChunkedData *	m_Data

int	m_ChunkIndex

CctwIntVector3D	m_ChunkStart

CctwIntVector3D	m_ChunkSize

CctwChunkedData::MergeDataType *	m_ChunkData

CctwChunkedData::MergeDataType *	m_ChunkWeights

int	m_Normalized

int	m_DataWritten

int	m_WeightsWritten

QVector< int >	m_Dependencies

QMutex	m_DependenciesLock

QMutex	m_MergeLock

int	m_MergeCounter

QList< CctwChunkedData::MergeDataType * >	m_MergeData

QList< CctwChunkedData::MergeDataType * >	m_MergeWeights

bool	m_OwnData

Additional Inherited Members
Properties inherited from CctwObject
QString	name

Detailed Description

Definition at line 11 of file cctwdatachunk.h.

Constructor & Destructor Documentation

CctwDataChunk::CctwDataChunk	(	CctwChunkedData *	data,
		int	index,
		QString	name,
		QObject *	parent
	)

Definition at line 8 of file cctwdatachunk.cpp.

References g_ChunkCount.

                                                                                             :
   CctwObject(name, parent),
   m_Data(data),
   m_ChunkIndex(index),
   m_ChunkStart(calculateChunkStart()),
   m_ChunkSize(calculateChunkSize()),
   m_ChunkData(NULL),
   m_ChunkWeights(NULL),
   m_Normalized(0),
   m_DataWritten(0),
   m_WeightsWritten(0),
   m_MergeCounter(0),
   m_OwnData(true)
 {
   g_ChunkCount.fetchAndAddOrdered(1);
 }

CctwDataChunk::~CctwDataChunk ( )

virtual

Definition at line 62 of file cctwdatachunk.cpp.

References dependencyCount(), g_ChunkCount, m_ChunkData, m_ChunkWeights, m_OwnData, CctwObject::printMessage(), and releaseBuffer().

 {
   if (dependencyCount()) {
     printMessage("Deleting chunk with deps");
   }
 
   if (m_OwnData) {
     releaseBuffer(m_ChunkData);
     releaseBuffer(m_ChunkWeights);
   }
 
   m_ChunkData = NULL;
   m_ChunkWeights = NULL;
 
   g_ChunkCount.fetchAndAddOrdered(-1);
 }

Member Function Documentation

void CctwDataChunk::addDependency ( int dep )

slot

Definition at line 337 of file cctwdatachunk.cpp.

References m_Dependencies, and m_DependenciesLock.

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   if (!m_Dependencies.contains(dep)) {
 //    printMessage(tr("Added dependency from chunk [%1,%2,%3] to chunk [%4,%5,%6]")
 //                 .arg(m_ChunkIndex.x()).arg(m_ChunkIndex.y()).arg(m_ChunkIndex.z())
 //                 .arg(dep.x()).arg(dep.y()).arg(dep.z()));
 
     m_Dependencies.append(dep);
   }
 }

CctwChunkedData::MergeDataType * CctwDataChunk::allocateBuffer ( )

private

Definition at line 260 of file cctwdatachunk.cpp.

References g_Allocated(), g_MaxAllocated(), m_ChunkSize, and CctwVector3D< T >::volume().

Referenced by allocateData(), and allocateWeights().

 {
   int cksz = m_ChunkSize.volume();
 
   int nalloc = g_Allocated.fetchAndAddOrdered(1);
 
   if (nalloc > g_MaxAllocated.fetchAndAddOrdered(0)) {
     g_MaxAllocated.fetchAndStoreOrdered(nalloc);
   }
 
 //  printMessage(tr("Acquired 1 blocks, %1 allocated, %2 max")
 //               .arg(nalloc).arg(g_MaxAllocated.fetchAndAddOrdered(0)));
 
 //  CctwChunkedData::MergeDataType *res = new CctwChunkedData::MergeDataType[cksz];
 
 //  for (int i=0; i<cksz; i++) {
 //    res[i] = 0;
 //  }
 
   CctwChunkedData::MergeDataType *res = (CctwChunkedData::MergeDataType*) calloc(sizeof(CctwChunkedData::MergeDataType), cksz);
 
   return res;
 }

int CctwDataChunk::allocateData ( )

slot

Definition at line 130 of file cctwdatachunk.cpp.

References allocateBuffer(), m_ChunkData, m_ChunkSize, releaseBuffer(), and CctwVector3D< T >::volume().

Referenced by mergeData(), CctwChunkedData::readChunk(), and CctwTransformer::transformChunkData().

 {
   int cksz = m_ChunkSize.volume();
 
   CctwChunkedData::MergeDataType *newData = allocateBuffer();
 
   releaseBuffer(m_ChunkData);
 
   m_ChunkData = newData;
 
   return cksz*sizeof(CctwChunkedData::MergeDataType);
 }

int CctwDataChunk::allocatedChunkCount ( )

staticslot

Definition at line 79 of file cctwdatachunk.cpp.

References g_ChunkCount.

Referenced by CctwChunkedData::allocatedChunkCount(), CctwTransformer::simpleTransform(), CctwTransformer::transform(), and CctwTransformer::transformChunkData().

 {
   return g_ChunkCount.fetchAndAddOrdered(0);
 }

int CctwDataChunk::allocateWeights ( )

slot

Definition at line 143 of file cctwdatachunk.cpp.

References allocateBuffer(), m_ChunkSize, m_ChunkWeights, releaseBuffer(), and CctwVector3D< T >::volume().

Referenced by mergeData(), CctwChunkedData::readChunk(), and CctwTransformer::transformChunkData().

 {
   int cksz = m_ChunkSize.volume();
 
   CctwChunkedData::MergeDataType *newWeights = allocateBuffer();
 
   releaseBuffer(m_ChunkWeights);
 
   m_ChunkWeights = newWeights;
 
   return cksz*sizeof(CctwChunkedData::MergeDataType);
 }

CctwIntVector3D CctwDataChunk::calculateChunkSize ( )

private

Definition at line 36 of file cctwdatachunk.cpp.

References CctwChunkedData::chunkSize, CctwChunkedData::dimensions, m_ChunkIndex, m_ChunkStart, m_Data, CctwObject::printMessage(), CctwVector3D< T >::x(), CctwVector3D< T >::y(), and CctwVector3D< T >::z().

 {
   if (m_Data) {
     CctwIntVector3D chksize = m_Data->chunkSize();
     CctwIntVector3D chkend = m_ChunkStart + chksize;
     CctwIntVector3D dim    = m_Data->dimensions();
 
     if (chkend.x() > dim.x()) {
       chksize.x() = dim.x() - m_ChunkStart.x();
     }
 
     if (chkend.y() > dim.y()) {
       chksize.y() = dim.y() - m_ChunkStart.y();
     }
 
     if (chkend.z() > dim.z()) {
       chksize.z() = dim.z() - m_ChunkStart.z();
     }
 
     return chksize;
   } else {
     printMessage(tr("Chunk %1, m_Data == NULL").arg(m_ChunkIndex));
     return CctwIntVector3D(0,0,0);
   }
 }

CctwIntVector3D CctwDataChunk::calculateChunkStart ( )

private

Definition at line 25 of file cctwdatachunk.cpp.

References chunkStart(), m_ChunkIndex, m_Data, and CctwObject::printMessage().

Referenced by resetChunkStart().

 {
 //  printMessage(tr("calculateChunkStart(): %1").arg(m_ChunkIndex));
   if (m_Data) {
     return m_Data -> chunkStart(m_ChunkIndex);
   } else {
     printMessage(tr("Chunk %1, m_Data == NULL").arg(m_ChunkIndex));
     return CctwIntVector3D(0,0,0);
   }
 }

CctwIntVector3D CctwDataChunk::chunkSize ( )

slot

Definition at line 120 of file cctwdatachunk.cpp.

References m_ChunkSize.

Referenced by CctwApplication::calculateChunkDependencies(), Cctwtcl_Input_Cmd(), Cctwtcl_Transform_Cmd(), CctwTransformer::dependencies(), mergeChunk(), and CctwTransformer::transformChunkData().

 {
   return m_ChunkSize;
 }

CctwIntVector3D CctwDataChunk::chunkStart ( )

slot

Definition at line 109 of file cctwdatachunk.cpp.

References m_ChunkStart.

Referenced by CctwApplication::calculateChunkDependencies(), calculateChunkStart(), CctwTransformer::dependencies(), and CctwTransformer::transformChunkData().

 {
   return m_ChunkStart;
 }

void CctwDataChunk::clearDependencies ( )

slot

Definition at line 309 of file cctwdatachunk.cpp.

References m_Dependencies, and m_DependenciesLock.

Referenced by CctwChunkedData::clearDependencies().

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   m_Dependencies.resize(0);
 }

void CctwDataChunk::clearMergeCounters ( )

slot

Definition at line 479 of file cctwdatachunk.cpp.

References m_MergeCounter, and m_Normalized.

 {
   m_MergeCounter = 0;
   m_Normalized   = 0;
 }

CctwChunkedData::MergeDataType CctwDataChunk::data	(	int	lx,
		int	ly,
		int	lz
	)

slot

Definition at line 206 of file cctwdatachunk.cpp.

References m_ChunkData, and pixelOffset().

Referenced by pushMergeData(), and CctwTransformer::transformChunkData().

 {
   int offset = pixelOffset(lx, ly, lz);
 
   if (offset >= 0 && m_ChunkData) {
     return m_ChunkData[offset];
   } else {
     return 0;
   }
 }

bool CctwDataChunk::dataAllocated ( ) const

slot

Definition at line 99 of file cctwdatachunk.cpp.

References m_ChunkData.

 {
   return m_ChunkData;
 }

CctwChunkedData::MergeDataType * CctwDataChunk::dataPointer ( )

slot

Definition at line 89 of file cctwdatachunk.cpp.

References m_ChunkData.

Referenced by Cctwtcl_Input_Cmd(), Cctwtcl_Transform_Cmd(), CctwTransformer::checkTransform(), CctwChunkedData::readChunk(), and CctwChunkedData::writeChunk().

 {
   return m_ChunkData;
 }

int CctwDataChunk::deallocateData ( )

slot

Definition at line 156 of file cctwdatachunk.cpp.

References m_ChunkData, m_ChunkSize, releaseBuffer(), and CctwVector3D< T >::volume().

Referenced by CctwChunkedData::releaseChunkData(), and CctwTransformer::transformChunkNumber().

 {
   int res = m_ChunkData ? m_ChunkSize.volume()*sizeof(CctwChunkedData::MergeDataType) : 0;
 
   releaseBuffer(m_ChunkData);
 
   m_ChunkData = NULL;
 
   return res;
 }

int CctwDataChunk::deallocateWeights ( )

slot

Definition at line 167 of file cctwdatachunk.cpp.

References m_ChunkSize, m_ChunkWeights, releaseBuffer(), and CctwVector3D< T >::volume().

Referenced by normalizeChunk(), CctwChunkedData::releaseChunkData(), and CctwTransformer::transformChunkNumber().

 {
   int res = m_ChunkWeights ? m_ChunkSize.volume()*sizeof(CctwChunkedData::MergeDataType) : 0;
 
   releaseBuffer(m_ChunkWeights);
 
   m_ChunkWeights = NULL;
 
   return res;
 }

int CctwDataChunk::dependency ( int n ) const

slot

Definition at line 330 of file cctwdatachunk.cpp.

References m_Dependencies, and m_DependenciesLock.

Referenced by CctwqtMainWindow::reportDependencies(), CctwTransformer::saveDependencies(), and CctwTransformer::transform().

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   return m_Dependencies.value(n);
 }

int CctwDataChunk::dependencyCount ( ) const

slot

Definition at line 323 of file cctwdatachunk.cpp.

References m_Dependencies, and m_DependenciesLock.

Referenced by CctwTransformer::checkTransform(), mergeChunk(), CctwqtMainWindow::reportDependencies(), CctwApplication::reportInputChunkCounts(), CctwApplication::reportOutputChunkCounts(), CctwTransformer::saveDependencies(), CctwTransformer::transform(), CctwTransformer::transformChunkNumber(), and ~CctwDataChunk().

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   return m_Dependencies.count();
 }

int CctwDataChunk::detachData ( )

slot

Definition at line 178 of file cctwdatachunk.cpp.

References m_ChunkData.

Referenced by Cctwtcl_Input_Cmd(), and Cctwtcl_Transform_Cmd().

 {
   m_ChunkData = NULL;
 
   return 0;
 }

int CctwDataChunk::detachWeights ( )

slot

Definition at line 185 of file cctwdatachunk.cpp.

References m_ChunkWeights.

Referenced by Cctwtcl_Input_Cmd(), and Cctwtcl_Transform_Cmd().

 {
   m_ChunkWeights = NULL;
 
   return 0;
 }

void CctwDataChunk::incMergeCounters ( )

slot

Definition at line 485 of file cctwdatachunk.cpp.

References m_MergeCounter.

Referenced by mergeChunk().

 {
   m_MergeCounter++;
 }

int CctwDataChunk::index ( ) const

slot

Definition at line 304 of file cctwdatachunk.cpp.

References m_ChunkIndex.

Referenced by Cctwtcl_Transform_Cmd(), CctwChunkedData::chunk(), mergeChunk(), CctwChunkedData::mergeChunk(), mergeData(), and normalizeChunk().

 {
   return m_ChunkIndex;
 }

int CctwDataChunk::maxAllocated ( )

staticslot

Definition at line 255 of file cctwdatachunk.cpp.

References g_MaxAllocated().

 {
   return g_MaxAllocated.fetchAndAddOrdered(0);
 }

void CctwDataChunk::mergeChunk ( CctwDataChunk * c )

slot

Definition at line 400 of file cctwdatachunk.cpp.

References chunkSize(), dependencyCount(), CctwChunkedData::incChunksHeld(), CctwChunkedData::incChunksWritten(), incMergeCounters(), index(), m_ChunkIndex, m_Data, mergeCount(), popMergeData(), CctwObject::printMessage(), pushMergeData(), releaseBuffer(), CctwVector3D< T >::volume(), and CctwChunkedData::writeChunk().

 {
 //  printMessage(tr("Merging chunk [%1]")
 //               .arg(index()));
 
   if (c) {
     if (mergeCount() == 0) {
 //      printMessage(tr("Output chunk [%1] started")
 //                   .arg(index()));
     }
 
     if (c->index() != index()) {
       printMessage(tr("Merging anomaly [%1] != [%2]")
                    .arg(index()).arg(c->index()));
     }
 
     CctwChunkedData::MergeDataType *d, *w, *id, *iw;
     c -> popMergeData(&id, &iw);
 
     while (popMergeData(&d, &w))  {
 //      printMessage(tr("Pop Merge"));
 
       CctwIntVector3D cks = chunkSize();
       CctwIntVector3D icks = c->chunkSize();
 
       if (cks == icks) {
         int n = cks.volume();
 
         if (d && id) {
           for (int i=0; i<n; i++) {
             if ((w && w[i] != 0) || !w) {
               id[i] += d[i];
             }
           }
         } else if (d) {
           id = d;
           d = NULL;
         }
 
         if (w && iw) {
           for (int i=0; i<n; i++) {
             iw[i] += w[i];
           }
         } else if (w) {
           iw = w;
           w = NULL;
         }
       } else {
         printMessage(tr("Anomaly merging data chunk %1").arg(m_ChunkIndex));
       }
 
       releaseBuffer(d);
       releaseBuffer(w);
     }
 
     pushMergeData(id, iw);
 
     incMergeCounters();
 
     if (mergeCount() == dependencyCount()) {
 //      printMessage(tr("Output chunk [%1] completed")
 //                   .arg(index()));
 
       if (m_Data) {
         m_Data->writeChunk(index());
         m_Data->incChunksWritten(1);
         m_Data->incChunksHeld(-1);
       }
     } else if (mergeCount() == 1) {
       if (m_Data) {
         m_Data->incChunksHeld(1);
       }
     } else if (mergeCount() > dependencyCount() && dependencyCount()) {
       printMessage(tr("Exceeded expected number of merges for chunk [%1] %2 > %3")
                    .arg(index()).arg(mergeCount()).arg(dependencyCount()));
     }
   }
 }

int CctwDataChunk::mergeCount ( )

slot

Definition at line 490 of file cctwdatachunk.cpp.

References m_MergeCounter.

Referenced by CctwTransformer::checkTransform(), and mergeChunk().

 {
   return m_MergeCounter;
 }

void CctwDataChunk::mergeData	(	CctwChunkedData::MergeDataType *	id,
		CctwChunkedData::MergeDataType *	iw,
		int	n
	)

slot

Definition at line 365 of file cctwdatachunk.cpp.

References allocateData(), allocateWeights(), index(), m_ChunkData, m_ChunkWeights, m_MergeLock, and CctwObject::printMessage().

Referenced by Cctwtcl_Merge_Cmd().

 {
   QMutexLocker lock(&m_MergeLock);
 
   if (m_ChunkData == NULL) {
     allocateData();
   }
 
   if (m_ChunkWeights == NULL) {
     allocateWeights();
   }
 
   CctwChunkedData::MergeDataType *d = m_ChunkData, *w = m_ChunkWeights;
 
   if (d && id) {
     for (int i=0; i<n; i++) {
       if ((iw && iw[i] != 0 && iw[i] == iw[i]) || !iw) {
         d[i] += id[i];
       }
     }
   } else {
     printMessage(tr("Couldn't merge data for chunk [%1]").arg(index()));
   }
 
   if (w && iw) {
     for (int i=0; i<n; i++) {
       if ((iw && iw[i] != 0 && iw[i] == iw[i]) || !iw) {
         w[i] += iw[i];
       }
     }
   }
 }

void CctwDataChunk::normalizeChunk ( )

slot

Definition at line 541 of file cctwdatachunk.cpp.

References deallocateWeights(), index(), m_ChunkData, m_ChunkSize, m_ChunkWeights, m_Normalized, CctwObject::printMessage(), and CctwVector3D< T >::volume().

Referenced by CctwChunkedData::normalizeChunk().

 {
   if (m_Normalized) {
     printMessage(tr("Chunk %1 - Already normalized").arg(index()));
   } else if (m_ChunkData && m_ChunkWeights) {
     int cksz = m_ChunkSize.volume();
 
     for (int i=0; i<cksz; i++) {
       if (m_ChunkWeights[i] != 0.0) {
         m_ChunkData[i] /= m_ChunkWeights[i];
       }
     }
 
     deallocateWeights();
   }
 
   m_Normalized = true;
 }

int CctwDataChunk::pixelOffset	(	int	lx,
		int	ly,
		int	lz
	)

slot

Definition at line 192 of file cctwdatachunk.cpp.

References m_ChunkSize, CctwVector3D< T >::x(), CctwVector3D< T >::y(), and CctwVector3D< T >::z().

Referenced by data(), setData(), setWeight(), and weight().

 {
   if (lx < 0 || lx >= m_ChunkSize.x()) {
     return -1;
   } else if (ly < 0 || ly >= m_ChunkSize.y()) {
     return -1;
   } else if (lz < 0 || lz >= m_ChunkSize.z()) {
     return -1;
   } else {
     int offset = (lz * m_ChunkSize.y() + ly)*m_ChunkSize.x() + lx;
     return offset;
   }
 }

bool CctwDataChunk::popMergeData	(	CctwChunkedData::MergeDataType **	data,
		CctwChunkedData::MergeDataType **	weights
	)

slot

Definition at line 495 of file cctwdatachunk.cpp.

References m_ChunkData, m_ChunkWeights, m_MergeData, m_MergeLock, and m_MergeWeights.

Referenced by mergeChunk().

 {
   QMutexLocker lock(&m_MergeLock);
 
   if (data && weights) {
     *data = m_ChunkData;
 
     if (m_MergeData.isEmpty()) {
       m_ChunkData = NULL;
     } else {
       m_ChunkData = m_MergeData.takeLast();
     }
 
     *weights = m_ChunkWeights;
 
     if (m_MergeWeights.isEmpty()) {
       m_ChunkWeights = NULL;
     } else {
       m_ChunkWeights = m_MergeWeights.takeLast();
     }
 
     return *data || *weights;
   } else {
     return false;
   }
 }

void CctwDataChunk::pushMergeData	(	CctwChunkedData::MergeDataType *	data,
		CctwChunkedData::MergeDataType *	weights
	)

slot

Definition at line 523 of file cctwdatachunk.cpp.

References data(), m_ChunkData, m_ChunkWeights, m_MergeData, m_MergeLock, and m_MergeWeights.

Referenced by mergeChunk().

 {
   QMutexLocker lock(&m_MergeLock);
 
   if (m_ChunkData == NULL) {
     m_ChunkData = data;
   } else {
     m_MergeData.push_back(data);
   }
 
   if (m_ChunkWeights == NULL) {
     m_ChunkWeights = weights;
   } else {
     m_MergeWeights.push_back(weights);
   }
 }

void CctwDataChunk::releaseBuffer ( CctwChunkedData::MergeDataType * buffer )

private

Definition at line 291 of file cctwdatachunk.cpp.

References g_Allocated().

Referenced by allocateData(), allocateWeights(), deallocateData(), deallocateWeights(), mergeChunk(), and ~CctwDataChunk().

 {
   if (buffer) {
     int nalloc = g_Allocated.fetchAndAddOrdered(-1);
 
 //    printMessage(tr("Releasing 1 blocks, %1 allocated").arg(nalloc));
 
 //    delete [] buffer;
 
     free(buffer);
   }
 }

void CctwDataChunk::reportDependencies ( )

slot

Definition at line 350 of file cctwdatachunk.cpp.

References m_ChunkIndex, m_Dependencies, m_DependenciesLock, CctwObject::printMessage(), and sortDependencies().

Referenced by CctwApplication::reportDependencies(), CctwApplication::reportInputDependencies(), and CctwApplication::reportOutputDependencies().

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   QString msg(tr("[%1] ->").arg(m_ChunkIndex));
 
   sortDependencies();
 
   foreach (int dep, m_Dependencies) {
     msg += tr(" [%1]").arg(dep);
   }
 
   printMessage(msg);
 }

void CctwDataChunk::resetAllocationLimits ( int nmax )

staticslot

Definition at line 246 of file cctwdatachunk.cpp.

References g_Allocated(), g_AllocationLimit(), g_Available(), and g_MaxAllocated().

Referenced by CctwTransformer::transform().

 {
   g_Allocated.fetchAndStoreOrdered(0);
   g_MaxAllocated.fetchAndStoreOrdered(0);
   g_AllocationLimit.fetchAndStoreOrdered(nmax);
   g_Available.acquire(g_Available.available());
   g_Available.release(nmax);
 }

void CctwDataChunk::resetChunkStart ( )

slot

Definition at line 114 of file cctwdatachunk.cpp.

References calculateChunkStart(), m_ChunkStart, and CctwVector3D< T >::toString().

 {
   m_ChunkStart = calculateChunkStart();
   qDebug("CctwDataChunk::resetChunkStart(): %s", qPrintable(m_ChunkStart.toString()));
 }

void CctwDataChunk::setBuffer ( void * buffer )

slot

Definition at line 284 of file cctwdatachunk.cpp.

References m_ChunkData, m_OwnData, and CctwObject::printMessage().

 {
   printMessage(tr("Setting buffer to: %1").arg((long long) buffer));
   m_ChunkData = (CctwChunkedData::MergeDataType*) buffer;
   m_OwnData = false;
 }

void CctwDataChunk::setChunkSize ( CctwIntVector3D size )

slot

Definition at line 125 of file cctwdatachunk.cpp.

References m_ChunkSize.

 {
   m_ChunkSize = size;
 }

void CctwDataChunk::setData	(	int	lx,
		int	ly,
		int	lz,
		CctwChunkedData::MergeDataType	val
	)

slot

Definition at line 228 of file cctwdatachunk.cpp.

References m_ChunkData, and pixelOffset().

 {
   int offset = pixelOffset(lx, ly, lz);
 
   if (offset >= 0 && m_ChunkData) {
     m_ChunkData[offset] = val;
   }
 }

void CctwDataChunk::setWeight	(	int	lx,
		int	ly,
		int	lz,
		CctwChunkedData::MergeDataType	val
	)

slot

Definition at line 237 of file cctwdatachunk.cpp.

References m_ChunkWeights, and pixelOffset().

 {
   int offset = pixelOffset(lx, ly, lz);
 
   if (offset >= 0 && m_ChunkWeights) {
     m_ChunkWeights[offset] = val;
   }
 }

void CctwDataChunk::sortDependencies ( )

slot

Definition at line 316 of file cctwdatachunk.cpp.

References m_Dependencies, and m_DependenciesLock.

Referenced by reportDependencies(), and CctwTransformer::saveDependencies().

 {
   QMutexLocker lock(&m_DependenciesLock);
 
   qSort(m_Dependencies.begin(), m_Dependencies.end());
 }

CctwChunkedData::MergeDataType CctwDataChunk::weight	(	int	lx,
		int	ly,
		int	lz
	)

slot

Definition at line 217 of file cctwdatachunk.cpp.

References m_ChunkWeights, and pixelOffset().

Referenced by CctwTransformer::transformChunkData().

 {
   int offset = pixelOffset(lx, ly, lz);
 
   if (offset >= 0 && m_ChunkWeights) {
     return m_ChunkWeights[offset];
   } else {
     return 1;
   }
 }