Replicate::Replicate(const std::vector<vec3> &points,Drawable *picture)
{
//Initialized
pointsObj = getDirections(points);
plottedPoints = points;
drawable = picture;
radian = 0;
}
void ObscuranceMainThread::run()
{
Q_ASSERT(m_volume);
m_stopped = false;
vtkVolumeRayCastMapper *mapper = vtkVolumeRayCastMapper::SafeDownCast(m_volume->GetMapper());
vtkEncodedGradientEstimator *gradientEstimator = mapper->GetGradientEstimator();
/// \TODO fent això aquí crec que va més ràpid, però s'hauria de comprovar i provar també amb l'Update()
gradientEstimator->GetEncodedNormals();
// Creem els threads
/// \todo QThread::idealThreadCount() amb Qt >= 4.3
int numberOfThreads = vtkMultiThreader::GetGlobalDefaultNumberOfThreads();
QVector<ObscuranceThread*> threads(numberOfThreads);
// Variables necessàries
vtkImageData *image = mapper->GetInput();
unsigned short *data = reinterpret_cast<unsigned short*>(image->GetPointData()->GetScalars()->GetVoidPointer(0));
int dataSize = image->GetPointData()->GetScalars()->GetSize();
int dimensions[3];
image->GetDimensions(dimensions);
vtkIdType vtkIncrements[3];
image->GetIncrements(vtkIncrements);
int increments[3];
increments[0] = vtkIncrements[0];
increments[1] = vtkIncrements[1];
increments[2] = vtkIncrements[2];
m_obscurance = new Obscurance(dataSize, hasColor(), m_doublePrecision);
for (int i = 0; i < numberOfThreads; i++)
{
ObscuranceThread * thread = new ObscuranceThread(i, numberOfThreads, m_transferFunction);
thread->setGradientEstimator(gradientEstimator);
thread->setData(data, dataSize, dimensions, increments);
thread->setObscuranceParameters(m_maximumDistance, m_function, m_variant, m_obscurance);
thread->setSaliency(m_saliency, m_fxSaliencyA, m_fxSaliencyB, m_fxSaliencyLow, m_fxSaliencyHigh);
threads[i] = thread;
}
// Estructures de dades reaprofitables
QVector<Vector3> lineStarts;
const QVector<Vector3> directions = getDirections();
int nDirections = directions.size();
// Iterem per les direccions
for (int i = 0; i < nDirections && !m_stopped; i++)
{
const Vector3 &direction = directions.at(i);
DEBUG_LOG(QString("Direcció %1: %2").arg(i).arg(direction.toString()));
// Direcció dominant (0 = x, 1 = y, 2 = z)
int dominant;
Vector3 absDirection(qAbs(direction.x), qAbs(direction.y), qAbs(direction.z));
if (absDirection.x >= absDirection.y)
{
if (absDirection.x >= absDirection.z)
{
dominant = 0;
}
else
{
dominant = 2;
}
}
else
{
if (absDirection.y >= absDirection.z)
{
dominant = 1;
}
else
{
dominant = 2;
}
}
// Vector per avançar
Vector3 forward;
switch (dominant)
{
case 0:
forward = Vector3(direction.x, direction.y, direction.z);
break;
case 1:
forward = Vector3(direction.y, direction.z, direction.x);
break;
case 2:
forward = Vector3(direction.z, direction.x, direction.y);
break;
}
// La direcció x passa a ser 1 o -1
forward /= qAbs(forward.x);
DEBUG_LOG(QString("forward = ") + forward.toString());
// Dimensions i increments segons la direcció dominant
int x = dominant, y = (dominant + 1) % 3, z = (dominant + 2) % 3;
int dimX = dimensions[x], dimY = dimensions[y], dimZ = dimensions[z];
int incX = increments[x], incY = increments[y], incZ = increments[z];
int sX = 1, sY = 1, sZ = 1;
qptrdiff startDelta = 0;
if (forward.x < 0.0)
{
startDelta += incX * (dimX - 1);
// incX = -incX;
forward.x = -forward.x;
sX = -1;
}
if (forward.y < 0.0)
{
startDelta += incY * (dimY - 1);
// incY = -incY;
forward.y = -forward.y;
sY = -1;
}
if (forward.z < 0.0)
{
startDelta += incZ * (dimZ - 1);
// incZ = -incZ;
forward.z = -forward.z;
sZ = -1;
}
DEBUG_LOG(QString("forward = ") + forward.toString());
// Ara els 3 components són positius
// Llista dels vòxels que són començament de línia
getLineStarts(lineStarts, dimX, dimY, dimZ, forward);
// int incXYZ[3] = { incX, incY, incZ };
int xyz[3] = { x, y, z };
int sXYZ[3] = { sX, sY, sZ };
// Iniciem els threads
for (int j = 0; j < numberOfThreads; j++)
{
ObscuranceThread * thread = threads[j];
thread->setPerDirectionParameters(direction, forward, xyz, sXYZ, lineStarts, startDelta);
thread->start();
}
// Esperem que acabin els threads
for (int j = 0; j < numberOfThreads; j++)
{
threads[j]->wait();
}
emit progress(100 * (i + 1) / nDirections);
}
// Destruïm els threads
for (int j = 0; j < numberOfThreads; j++)
{
delete threads[j];
}
// Si han cancel·lat el procés ja podem plegar
if (m_stopped)
{
emit progress(0);
delete m_obscurance; m_obscurance = 0;
return;
}
m_obscurance->normalize();
emit computed();
}
bool GridTable::isAssembled(Kmer*a){
Kmer reverse=complementVertex(a,m_parameters->getWordSize(),m_parameters->getColorSpaceMode());
return getDirections(a).size()>0||getDirections(&reverse).size()>0;
}
