GDCM  2.4.5
Fake_Image_Using_Stream_Image_Writer.cxx
/*=========================================================================
Program: GDCM (Grassroots DICOM). A DICOM library
Copyright (c) 2006-2011 Mathieu Malaterre
All rights reserved.
See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// This work was realised during the GSOC 2011 by Manoj Alwani
#include "gdcmReader.h"
#include "gdcmWriter.h"
#include "gdcmItem.h"
#include "gdcmAttribute.h"
#include "gdcmFile.h"
#include "gdcmTag.h"
#include "gdcmAnonymizer.h"
#include "gdcmTrace.h"
int main(int, char *[])
{
char * buffer = new char[ 256 * 256 *3 ];
// *p = (uint8_t*)buffer;
char * p = buffer;
for(int row = 0; row < 256; ++row)
{
for(int col = 0; col < 256; ++col)
//for(int b = 0; b < 256; ++b)
{
*p++ = 255;
*p++ = 0;
*p++ = 0;
}
}
gdcm::File &file = w.GetFile();
gdcm::DataSet &ds = file.GetDataSet();
gdcm::DataElement de( gdcm::Tag(0x8,0x18) ); // SOP Instance UID
const char *u = uid.Generate();
de.SetByteValue( u, strlen(u) );
ds.Insert( de );
gdcm::DataElement de1( gdcm::Tag(0x8,0x16) );
de1.SetByteValue( ms.GetString(), strlen(ms.GetString()));
ds.Insert( de1 );
const char mystr[] = "RGB";
gdcm::DataElement de2( gdcm::Tag(0x28,0x04) );
//de.SetTag(gdcm::Tag(0x28,0x04));
de2.SetByteValue(mystr, strlen(mystr));
ds.Insert( de2 );
//row.SetValue(512);
ds.Insert( row.GetAsDataElement() );
// w.SetCheckFileMetaInformation( true );
ds.Insert( col.GetAsDataElement() );
gdcm::Attribute<0x0028,0x0008> Number_Of_Frames = {1};
ds.Insert( Number_Of_Frames.GetAsDataElement() );
gdcm::Attribute<0x0028,0x0002> at1 = {3}; //bits per pixel
ds.Insert( at1.GetAsDataElement() );
ds.Insert( at2.GetAsDataElement() );
ds.Insert( at3.GetAsDataElement() );
ds.Insert( at4.GetAsDataElement() );
ds.Insert( at5.GetAsDataElement() );
//de.SetTag(gdcm::Tag(0x7fe0,0x0010));
//ds.Insert(de);
gdcm::StreamImageWriter theStreamWriter;
uint16_t row1 = 256;
uint16_t col1 = 256;
//std::cout << row;
el2.SetValue(1);
gdcm::DataElement rfn = el2.GetAsDataElement(); //rfn ---> reference frame number
rfn.SetTag( gdcm::Tag(0x0008,0x1160) );
el.SetValue(1,0);
el.SetValue(1,1);
gdcm::DataElement ulr = el.GetAsDataElement(); //ulr --> upper left col/row
ulr.SetTag( gdcm::Tag(0x0048,0x0201) );
el1.SetValue(col1,0);
el1.SetValue(row1,1);
brr.SetTag( gdcm::Tag(0x0048,0x0202) ); //brr --> bottom right col/row
nds.Insert( rfn );
nds.Insert(ulr);
nds.Insert(brr);
sq->AddItem(it);
gdcm::DataElement des( gdcm::Tag(0x0048,0x0200) );
des.SetValue(*sq);
ds.Insert(des);
theStreamWriter.SetFile(file);
std::ofstream of;
of.open( "output.dcm", std::ios::out | std::ios::binary );
theStreamWriter.SetStream(of);
if (!theStreamWriter.CanWriteFile()){
delete [] buffer;
std::cout << "Not able to write";
return 0;//this means that the file was unwritable, period.
//very similar to a ReadImageInformation failure
}
else
std::cout<<"\nabletoread";
if (!theStreamWriter.WriteImageInformation()){
std::cerr << "unable to write image information" << std::endl;
delete [] buffer;
return 1; //the CanWrite function should prevent getting here, else,
//that's a test failure
}
std::vector<unsigned int> extent =
unsigned short xmax = extent[0];
unsigned short ymax = extent[1];
unsigned short theChunkSize = 1;
unsigned short ychunk = extent[1]/theChunkSize; //go in chunk sizes of theChunkSize
unsigned short zmax = extent[2];
std::cout << xmax << ymax << zmax;
if (xmax == 0 || ymax == 0)
{
std::cerr << "Image has no size, unable to write zero-sized image." << std::endl;
return 0;
}
int z, y, nexty;
unsigned long prevLen = 0; //when going through the char buffer, make sure to grab
//the bytes sequentially. So, store how far you got in the buffer with each iteration.
for (z = 0; z < zmax; ++z){
for (y = 0; y < ymax; y += ychunk){
nexty = y + ychunk;
if (nexty > ymax) nexty = ymax;
theStreamWriter.DefinePixelExtent(0, xmax, y, nexty, z, z+1);
unsigned long len = theStreamWriter.DefineProperBufferLength();
std::cout << "\n" <<len;
char* finalBuffer = new char[len];
memcpy(finalBuffer, &(buffer[prevLen]), len);
std::cout << "\nable to write";
if (!theStreamWriter.Write(finalBuffer, len)){
std::cerr << "writing failure:" << "output.dcm" << " at y = " << y << " and z= " << z << std::endl;
delete [] buffer;
delete [] finalBuffer;
return 1;
}
delete [] finalBuffer;
prevLen += len;
}
}
delete buffer;
uint16_t firstTag1 = 0xfffe;
uint16_t secondTag1 = 0xe0dd;
uint32_t thirdTag1 = 0x00000000;
//uint16_t fourthTag1 = 0xffff;
const int theBufferSize1 = 2*sizeof(uint16_t)+sizeof(uint32_t);
char* tmpBuffer2 = new char[theBufferSize1];
memcpy(&(tmpBuffer2[0]), &firstTag1, sizeof(uint16_t));
memcpy(&(tmpBuffer2[sizeof(uint16_t)]), &secondTag1, sizeof(uint16_t));
memcpy(&(tmpBuffer2[2*sizeof(uint16_t)]), &thirdTag1, sizeof(uint32_t));
//memcpy(&(tmpBuffer2[3*sizeof(uint16_t)]), &fourthTag1, sizeof(uint16_t));
assert( of && !of.eof() && of.good() );
of.write(tmpBuffer2, theBufferSize1);
of.flush();
assert( of );
return 0;
}

Generated on Fri Sep 25 2015 17:58:20 for GDCM by doxygen 1.8.9.1
SourceForge.net Logo