void Texture::resetData()
{
if (m_textureType == TextureType::kColor)
{
m_data.reset(new UCharTextureData);
}
else if (m_textureType == TextureType::kFloat)
{
m_data.reset(new FloatTextureData);
}
else
{
throw std::runtime_error("Unrecognised texture type");
}
m_data->resize(width() * height() * nChannels());
}
int MRC::save(const char* filename) {
char *filenamesave_ext = new char[ strlen(filename) + 8 ];
strcpy(filenamesave_ext, filename);
strcat(filenamesave_ext,".mrc");
std::ofstream fout(filenamesave_ext, std::ios::binary);
fout.write(reinterpret_cast<const char*> (&nx), sizeof(int));
fout.write(reinterpret_cast<const char*> (&ny), sizeof(int));
fout.write(reinterpret_cast<const char*> (&nz), sizeof(int));
fout.write(reinterpret_cast<const char*> (&mode), sizeof(int));
fout.write(reinterpret_cast<const char*> (&nxStart), sizeof(int));
fout.write(reinterpret_cast<const char*> (&nyStart), sizeof(int));
fout.write(reinterpret_cast<const char*> (&nzStart), sizeof(int));
fout.write(reinterpret_cast<const char*> (&mx), sizeof(int));
fout.write(reinterpret_cast<const char*> (&my), sizeof(int));
fout.write(reinterpret_cast<const char*> (&mz), sizeof(int));
fout.write(reinterpret_cast<const char*> (&xlen), sizeof(float));
fout.write(reinterpret_cast<const char*> (&ylen), sizeof(float));
fout.write(reinterpret_cast<const char*> (&zlen), sizeof(float));
fout.write(reinterpret_cast<const char*> (&alpha), sizeof(float));
fout.write(reinterpret_cast<const char*> (&beta), sizeof(float));
fout.write(reinterpret_cast<const char*> (&gamma), sizeof(float));
fout.write(reinterpret_cast<const char*> (&mapc), sizeof(int));
fout.write(reinterpret_cast<const char*> (&mapr), sizeof(int));
fout.write(reinterpret_cast<const char*> (&maps), sizeof(int));
fout.write(reinterpret_cast<const char*> (&amin), sizeof(float));
fout.write(reinterpret_cast<const char*> (&amax), sizeof(float));
fout.write(reinterpret_cast<const char*> (&amean), sizeof(float));
fout.write(reinterpret_cast<const char*> (&ispq), sizeof(int));
fout.write(reinterpret_cast<const char*> (&next), sizeof(int));
fout.write(reinterpret_cast<const char*> (&creatid), sizeof(short));
fout.write(reinterpret_cast<const char*> (&extra_data), 30 * sizeof(char)); // !!! char 30
fout.write(reinterpret_cast<const char*> (&nint), sizeof(short));
fout.write(reinterpret_cast<const char*> (&nreal), sizeof(short));
fout.write(reinterpret_cast<const char*> (&extra_data_2), 20 * sizeof(char)); // !!! char 20
fout.write(reinterpret_cast<const char*> (&imodStamp), sizeof(int));
fout.write(reinterpret_cast<const char*> (&imodFlag), sizeof(int));
fout.write(reinterpret_cast<const char*> (&idtype), sizeof(short));
fout.write(reinterpret_cast<const char*> (&lens), sizeof(short));
fout.write(reinterpret_cast<const char*> (&nd1), sizeof(short));
fout.write(reinterpret_cast<const char*> (&nd2), sizeof(short));
fout.write(reinterpret_cast<const char*> (&vd1), sizeof(short));
fout.write(reinterpret_cast<const char*> (&vd2), sizeof(short));
fout.write(reinterpret_cast<const char*> (&tiltangles), 6 * sizeof(float));
fout.write(reinterpret_cast<const char*> (&xorg), sizeof(float));
fout.write(reinterpret_cast<const char*> (&yorg), sizeof(float));
fout.write(reinterpret_cast<const char*> (&zorg), sizeof(float));
fout.write(reinterpret_cast<const char*> (&cmap), 4 * sizeof(char));
fout.write(reinterpret_cast<const char*> (&stamp), 4 * sizeof(char));
fout.write(reinterpret_cast<const char*> (&rms), sizeof(float));
fout.write(reinterpret_cast<const char*> (&nlabl), sizeof(int));
fout.write(reinterpret_cast<const char*> (&vlabl), 10 * 80 * sizeof(char));
int nChannel = nChannels(mode);
void *oData = nullptr;
switch(mode) {
case 0:
oData = (unsigned char*) malloc1D(nx * ny * nz * nChannel, sizeof(char), "Output data unsigned char");
break;
case 1:
oData = (short*) malloc1D(nx * ny * nz * nChannel, sizeof(short), "Output data signed short");
break;
case 2:
oData = (float*) malloc1D(nx * ny * nz * nChannel, sizeof(float), "Output data float");
break;
case 3:
oData = (short*) malloc1D(nx * ny * nz * nChannel, sizeof(short), "Output data short * 2");
break;
case 4:
oData = (float*) malloc1D(nx * ny * nz * nChannel, sizeof(float), "Output data float * 2");
break;
case 6:
oData = (unsigned short*) malloc1D(nx * ny * nz * nChannel, sizeof(short), "Output data unsigned short");
break;
case 16:
oData = (unsigned char*) malloc1D(nx * ny * nz * nChannel, sizeof(char), "Output data unsigned char * 3");
default:
oData = nullptr;
break;
}
for(size_t k = 0; k < nz; k++) {
for(size_t i = 0; i < ny; i++) {
for(size_t j = 0; j < nx; j++) {
for(size_t l = 0; l < nChannel; l++) {
switch(mode) {
case 0: // unsigned char
case 16:
((unsigned char*) oData)[ nChannel * (nx * ny * k + nx * i + j) + l ] = ( (double*) pData)[ nChannel * (nx * ny * k + nx * i + j) + l ];
break;
case 1: // short
case 3:
((short*) oData)[ nChannel * (nx * ny * k + nx * i + j) + l ] = ( (double*) pData)[ nChannel * (nx * ny * k + nx * i + j) + l ];
break;
case 2: // float
case 4:
((float*) oData)[ nChannel * (nx * ny * k + nx * i + j) + l ] = ( (double*) pData)[ nChannel * (nx * ny * k + nx * i + j) + l ];
break;
case 6: // unsigned short
((unsigned short*) oData)[ nChannel * (nx * ny * k + nx * i + j) + l ] = ( (double*) pData)[ nChannel * (nx * ny * k + nx * i + j) + l ];
break;
default:
break;
}
}
}
}
}
fout.write(reinterpret_cast<const char*> (oData), this->nx * this->ny * this->nz * sizeof(float) * nChannel);
delete[] oData;
fout.close();
delete[] filenamesave_ext;
return 0;
}
bool MipData::loadMy4DImage(const My4DImage* img, const My4DImage* maskImg)
{
// Validate data in this thread
if (!img) return false;
benchmark.start();
dataMin = 1e9;
dataMax = -1e9;
data.assign(img->getXDim(), MipData::Column(img->getYDim(), MipData::Pixel(img->getCDim()))); // 50 ms
// qDebug() << "size = " << data.size();
// qDebug() << "nColumns = " << nColumns();
// MipData& t = *this;
volume4DImage = img;
My4DImage * mutable_img = const_cast<My4DImage*>(img);
Image4DProxy<My4DImage> imgProxy(mutable_img);
numNeurons = 0;
NeuronChannelIntegratorList neuronColors;
// First loop "quickly" updates intensity, without updating neuron masks
for (int x = 0; x < nColumns(); ++x) {
for (int y = 0; y < nRows(); ++y) {
for (int z = 0; z < img->getZDim(); ++z)
{
int neuronIndex = -1;
if (maskImg) {
neuronIndex = maskImg->at(x, y, z);
if (neuronIndex >= numNeurons) {
numNeurons = neuronIndex + 1;
neuronColors.resize(numNeurons, NeuronChannelIntegrator(nChannels(), 0.0));
}
}
float intensity = 0.0;
for (int c = 0; c < nChannels(); ++c) {
float val = (float)imgProxy.value_at(x,y,z,c);
// Update minimum and maximum values
if (val > dataMax) dataMax = val;
if (val < dataMin) dataMin = val;
// Update current voxel intensity
intensity += val;
if (neuronIndex >= 0)
neuronColors[neuronIndex][c] += val;
}
assert(intensity >= 0.0);
// Maximum intensity projection - regardless of neuron masks
if (intensity > data[x][y].intensity) {
for (int c = 0; c < nChannels(); ++c)
data[x][y][c] = (float)imgProxy.value_at(x,y,z,c);
data[x][y].z = z; // remember z-value of max intensity pixel
data[x][y].intensity = intensity;
if (maskImg) {
data[x][y].neuronIndex = (int) maskImg->at(x, y, z);
}
}
}
}
if (! (x % 10))
emit processedXColumn(x + 1);
// qDebug() << "processed column " << x + 1;
}
qDebug() << "Computing MIP took " << benchmark.restart() << " milliseconds";
for (int n = 0; n < neuronColors.size(); ++n)
{
NeuronChannelIntegrator& neuronColor = neuronColors[n];
// find maximum
double maxCount = -1e9;
for (int c = 0; c < neuronColor.size(); ++c) {
double channelCount = neuronColor[c];
if (channelCount > maxCount)
maxCount = channelCount;
}
// scale by maximum
for (int c = 0; c < neuronColor.size(); ++c) {
neuronColor[c] /= maxCount;
}
}
qDebug() << "Computing neuron colors took " << benchmark.restart() << " milliseconds";
// TODO - actually use the color information
emit intensitiesUpdated();
// Populate individual neuron mip layers
if (maskImg && (numNeurons > 0))
{
if (neuronLayers) delete [] neuronLayers;
neuronLayers = new MipLayer*[numNeurons];
for (int i = 0; i < numNeurons; ++i)
neuronLayers[i] = new MipLayer(QSize(nColumns(), nRows()), this);
qDebug() << "processing MIP masks";
for (int x = 0; x < nColumns(); ++x) {
for (int y = 0; y < nRows(); ++y) {
for (int z = 0; z < img->getZDim(); ++z)
{
int neuronMaskId = maskImg->at(x,y,z);
if (neuronMaskId < 0) continue;
float intensity = 0.0;
for (int c = 0; c < nChannels(); ++c)
intensity += (float)imgProxy.value_at(x,y,z,c);
assert(intensity >= 0.0);
MipLayer::Pixel& currentPixel = neuronLayers[neuronMaskId]->getPixel(x, y);
if ( (currentPixel.neuronIndex != neuronMaskId) // no data for this neuron so far
|| (intensity > currentPixel.intensity) ) // brightest intensity seen so far
{
currentPixel.neuronIndex = neuronMaskId;
currentPixel.zCoordinate = z;
currentPixel.intensity = intensity;
}
}
}
}
qDebug() << "finished creating MIP masks; took " << benchmark.restart() << " milliseconds";
// TODO create binary tree of mip layers leading to combined image
std::vector<MipLayer*> layers;
for (int n = 0; n < numNeurons; ++n) {
layers.push_back(neuronLayers[n]);
}
while (layers.size() > 1) {
std::vector<MipLayer*> nextLevel;
while (layers.size() > 0) {
MipLayer* node1 = layers.back(); layers.pop_back();
MipLayer* node2 = NULL;
if (layers.size() > 0) {
node2 = layers.back();
layers.pop_back();
}
nextLevel.push_back(new MipLayer(node1, node2, this));
}
layers = nextLevel;
qDebug() << "layers size = " << layers.size();
}
assert(layers.size() == 1);
combinedMipLayer = layers.back();
connect(combinedMipLayer, SIGNAL(layerChanged()),
this, SLOT(onCombinedMipLayerUpdated()));
qDebug() << "Creating MIP layer binary tree took " << benchmark.restart() << " milliseconds";
}
return true;
}
