Пример #1
0
/** Check whether given type 1 attribute is present and has a length > 0.
*  @param  key - [in] The attribute tag check
*  @param  targetDset - [out] targetDset
*  @param  defaultValue - [in] value to be inserted if attribute is missing
*                         (needs invent option for type 1 attributes enabled)
*  @return A string with an error message if attribute is not present
*          or has length of 0
*/
OFString D2DCommon::checkAndInventType1Attrib(const DcmTagKey& key,
                DcmDataset* targetDset,
                const OFString& defaultValue) const
{
        OFString err;
        OFBool exists = targetDset->tagExists(key);
        if (!exists) {
                OFString err = "Document2Dcm: Missing type 1 attribute: ";
                err += DcmTag(key).getTagName();
                err += "\n";
                return err;
        }
        DcmElement *elem;
        OFCondition cond = targetDset->findAndGetElement(key, elem);
        if (cond.bad() || !elem || (elem->getLength() == 0)) {
                if (!m_inventMissingType1Attribs) {
                        err += "Document2Dcm: Empty value for type 1 attribute: ";
                        err += DcmTag(key).getTagName();
                        err += "\n";
                        return err;
                }
                //holds element to insert in item
                DcmElement *elem = NULL;
                DcmTag tag(key);
                OFBool wasError = OFFalse;
                //if dicom element could be created, insert in to item and modify to value
                if (newDicomElement(elem, tag).good()) {
                        if (targetDset->insert(elem, OFTrue).good()) {
                                if (elem->putString(defaultValue.c_str()).good()) {
                                        if (m_debug) {
                                                OFString msg = "Document2Dcm: Inserting missing type 1 attribute ";
                                                msg += tag.getTagName();
                                                msg += " with value ";
                                                msg += defaultValue;
                                                printMessage(m_logStream, msg);
                                                return err;
                                        }
                                } else wasError = OFTrue;
                        } else wasError = OFTrue;
                } else wasError = OFTrue;
                if (wasError) {
                        err += "Unable to insert type 1 attribute ";
                        err += tag.getTagName();
                        err += " with value ";
                        err += defaultValue;
                        err += "\n";
                }
        }
        return err;
}
Пример #2
0
 // copy optional string value from dataset to directory record
 static void copyStringWithDefault(DcmItem& dataset,
                                   const DcmTagKey &key,
                                   DcmDirectoryRecord& record,
                                   const char *defaultValue,
                                   const OFBool printWarning)
 {
     OFCondition status;
     if (dataset.tagExistsWithValue(key))
     {
       OFString stringValue;
       /* retrieve string value from source dataset and put it into the destination dataset */
       status = dataset.findAndGetOFStringArray(key, stringValue);
       if (status.good())
         status = record.putAndInsertString(key, stringValue.c_str());
     } else {
       if (printWarning && (defaultValue != NULL))
       {
         /* create warning message */
         LOG(WARNING) << "DICOMDIR: " << DcmTag(key).getTagName() << " "
                      << key << " missing, using alternative: " << defaultValue;
       }
       /* put default value */
       status = record.putAndInsertString(key, defaultValue);
     }
 }
Пример #3
0
 // print an error message to the console (stderr) that something went wrong with an attribute
 static void printAttributeErrorMessage(const DcmTagKey &key,
                                        const OFCondition &error,
                                        const char *operation)
 {
   if (error.bad())
   {
     OFString str;
     if (operation != NULL)
     {
       str = "cannot ";
       str += operation;
       str += " ";
     }
     LOG(ERROR) << error.text() << ": " << str << DcmTag(key).getTagName() << " " << key;
   }
 }
Пример #4
0
/** Inserts an empty element with the given tag into a dataset
*  @param  key - [in] The attribute tag to check
*  @param  targetDset - [out] targetDset
*  @return A string with an error message if attribute is not present
*          nor gets inserted automatically (see m_inventMissingType2Attribs)
*/
OFString D2DCommon::checkAndInventType2Attrib(const DcmTagKey& key,
                DcmDataset* targetDset) const
{
        OFString err;
        OFBool exists = targetDset->tagExists(key);
        if (!exists) {
                if (m_inventMissingType2Attribs) {
                        DcmTag tag(key);
                        if (m_debug)
                                printMessage(m_logStream, "Document2Dcm: Inserting missing type 2 attribute: ", tag.getTagName());
                        targetDset->insertEmptyElement(tag);
                } else {
                        err = "Document2Dcm: Missing type 2 attribute: ";
                        err += DcmTag(key).getTagName();
                        err += "\n";
                        return err;
                }
        }
        return err;
}
Пример #5
0
/** Reads pixel data and corresponding attributes like rows etc. from image
*  file and inserts them into dataset.
*  @param dset - [out] The dataset to export the pixel data attributes to
*  @param outputTS - [out] The proposed transfex syntax of the dataset
*  @return EC_Normal, if successful, error otherwise
*/
OFCondition I2DImgSource::readAndInsertSpecificTags( DcmDataset* dset, E_TransferSyntax& outputTS)
{
        Uint16 samplesPerPixel, rows, cols, bitsAlloc, bitsStored, highBit, pixelRepr, planConf;
        Uint16 pixAspectH = 1;
        Uint16 pixAspectV = 1;
        OFString photoMetrInt;
        outputTS = EXS_Unknown;
        char* pixData = NULL;
        Uint32 length;

        OFCondition cond = readPixelData(rows, cols,
                                         samplesPerPixel, photoMetrInt, bitsAlloc, bitsStored, highBit, pixelRepr,
                                         planConf, pixAspectH, pixAspectV, pixData, length, outputTS);
        if (cond.bad())
                return cond;

        if (m_debug)
                printMessage(m_logStream, "Document2Dcm: Store imported pixel data to DICOM file");

        cond = dset->putAndInsertUint16(DCM_SamplesPerPixel, samplesPerPixel);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertOFStringArray(DCM_PhotometricInterpretation, photoMetrInt);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertOFStringArray(DCM_ConversionType, "WSD");
        if (cond.bad())
                return cond;
        /*
        cond = dset->putAndInsertOFStringArray(DCM_ImagerPixelSpacing, "1.000000\\1.000000");
        if (cond.bad())
        return cond;

        cond = dset->putAndInsertOFStringArray(DCM_PixelSpacing, "1.000000\\1.000000");
        if (cond.bad())
        return cond;
        */
        cond = dset->putAndInsertOFStringArray(DCM_ImagePositionPatient, "0.000000\\0.000000\\0.000000");
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertOFStringArray(DCM_ImageOrientationPatient, "1.000000\\0.000000\\0.000000\\0.000000\\1.000000\\0.000000");
        if (cond.bad())
                return cond;


        // Should only be written if Samples per Pixel > 1
        if (samplesPerPixel > 1) {
                cond = dset->putAndInsertUint16(DCM_PlanarConfiguration, planConf);
                if (cond.bad())
                        return cond;
        }

        cond = dset->putAndInsertUint16(DCM_Rows, rows);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertUint16(DCM_Columns, cols);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertUint16(DCM_BitsAllocated, bitsAlloc);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertUint16(DCM_BitsStored, bitsStored);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertUint16(DCM_HighBit, highBit);
        if (cond.bad())
                return cond;

        cond = dset->putAndInsertUint16(DCM_PixelRepresentation, pixelRepr);
        if (cond.bad())
                return cond;


        if (Recompress()) {
                // create initial pixel sequence
                DcmElement* element = newDicomElement(DcmTag(DCM_PixelData, EVR_OW));
                element->putUint8Array((const Uint8*)pixData, length);
                cond = dset->insert(element);
                if (cond.bad()) {
                        delete element;
                        return cond;
                }

                //lo pasamos a jpeg lossless
                // create representation parameters for lossy and lossless
                OFCmdUnsignedInt opt_selection_value = 6;
                //este numero implica cierta perdida... si fuera 0 seria lossless real
                OFCmdUnsignedInt opt_point_transform = 3;

                E_TransferSyntax opt_oxfer;
                GNC::GCS::Permisos::EstadoPermiso codificacion = GNC::GCS::IControladorPermisos::Instance()->Get("core.importacion", "codec");
                switch (codificacion.ObtenerValor<int>()) {
                case 0: {
                        //baseline
                        opt_oxfer = EXS_JPEGProcess1;
                        DJ_RPLossy rp_lossy((int)90);
                        const DcmRepresentationParameter *rp = &rp_lossy;
                        dset->chooseRepresentation(opt_oxfer, rp);
                }
                break;
                case 1: {
                        //progresivo
                        opt_oxfer = EXS_JPEGProcess10_12;
                        DJ_RPLossy rp_lossy((int)90);
                        const DcmRepresentationParameter *rp = &rp_lossy;
                        dset->chooseRepresentation(opt_oxfer, rp);
                }
                break;
                case 2:
                default: {
                        //lossless
                        GNC::GCS::Permisos::EstadoPermiso estado = GNC::GCS::IControladorPermisos::Instance()->Get("core.importacion", "quality");
                        if (estado) {
                                opt_point_transform = std::min<int>(estado.ObtenerValor<int>(), 14);
                                opt_point_transform = std::max<int>(estado.ObtenerValor<int>(), 0);
                        }
                        opt_oxfer = EXS_JPEGProcess14SV1;
                        DJ_RPLossless rp_lossless((int)opt_selection_value, (int)opt_point_transform);
                        const DcmRepresentationParameter *rp = &rp_lossless;
                        dset->chooseRepresentation(opt_oxfer, rp);
                }
                break;
                }

                if(!dset->canWriteXfer(opt_oxfer))
                        return OFCondition(EC_UnsupportedEncoding);

                // force meta-header to refresh SOP Class/Instance UIDs.
                delete dset->remove(DCM_MediaStorageSOPClassUID);
                delete dset->remove(DCM_MediaStorageSOPInstanceUID);
                outputTS = opt_oxfer;

                return cond;
        } else {
                if (IsCompressed()) {
                        DcmPixelSequence *pixelSequence = NULL;

                        if (m_debug)
                                printMessage(m_logStream, "Document2Dcm: Store imported pixel data to DICOM file");
                        // create initial pixel sequence
                        pixelSequence = new DcmPixelSequence(DcmTag(DCM_PixelData, EVR_OB));
                        if (pixelSequence == NULL)
                                return EC_MemoryExhausted;
                        // insert empty offset table into sequence
                        DcmPixelItem *offsetTable = new DcmPixelItem(DcmTag(DCM_Item, EVR_OB));
                        if (offsetTable == NULL) {
                                delete pixelSequence;
                                pixelSequence = NULL;
                                return EC_MemoryExhausted;
                        }
                        cond = pixelSequence->insert(offsetTable);
                        if (cond.bad()) {
                                delete offsetTable;
                                offsetTable = NULL;
                                delete pixelSequence;
                                pixelSequence = NULL;
                                return cond;
                        }

                        // insert frame into pixel sequence
                        DcmOffsetList dummyList;
                        cond = pixelSequence->storeCompressedFrame(dummyList, (Uint8*) pixData, length, 0);
                        // storeCompressedFrame(..) does a deep copy, so the pixdata memory can be freed now
                        delete[] pixData;
                        if (cond.bad()) {
                                delete pixelSequence;
                                return cond;
                        }
                        cond = dset->insert(pixelSequence);
                        if (cond.bad())
                                delete pixelSequence;

                        if (m_debug)
                                printMessage(m_logStream, "Document2Dcm: Inserting Image Pixel module information");
                        return dset->putAndInsertUint16(DCM_PixelRepresentation, pixelRepr);
                } else {
                        //little endian to little endian...
                        // create initial pixel sequence
                        DcmElement* element = newDicomElement(DcmTag(DCM_PixelData, EVR_OW));
                        element->putUint8Array((const Uint8*)pixData, length);
                        cond = dset->insert(element);
                        if (cond.bad()) {
                                delete element;
                                return cond;
                        }
                        outputTS = EXS_LittleEndianExplicit;

                        return cond;
                }
        }
}
Пример #6
0
int ctkDICOMDatasetTest1( int argc, char * argv [] )
{
  Q_UNUSED(argc);
  Q_UNUSED(argv);
  ctkDICOMDataset dataset;
  dataset.InitializeFromDataset(0);
  dataset.InitializeFromFile(QString());
  try
    {
    dataset.Serialize();
    }
  catch(...)
    {
    std::cout << "ctkDICOMDataset::Serialize() throws exceptions" << std::endl;
    //return EXIT_FAILURE;
    }
  try
    {
    dataset.Deserialize();
    }
  catch(...)
    {
    std::cout << "ctkDICOMDataset::Deserialize() throws exceptions"
              << std::endl;
    //return EXIT_FAILURE;
    }
  dataset.MarkForInitialization();
  try
    {
    dataset.EnsureDcmDataSetIsInitialized();
    }
  catch(...)
    {
    std::cout << "ctkDICOMDataset::EnsureDcmDataSetIsInitialized() throws"
              << " exceptions" << std::endl;
    //return EXIT_FAILURE;
    }

  // deactivating the lower part since it (correctly) causes
  // execptions since it calls methods on an uninitialized object
  return EXIT_SUCCESS;

  dataset.CopyElement(0, DcmTagKey(), 0);
  QString decode = dataset.Decode(DcmTag(),OFString());
  if (!decode.isEmpty())
    {
    std::cerr << "ctkDICOMDataset::Decode() failed: "
              << qPrintable(decode) << std::endl;
    return EXIT_FAILURE;
    }
  OFString encode = dataset.Encode(DcmTag(), decode);
  DcmElement* element = 0;
  OFCondition condition = dataset.findAndGetElement(DcmTag(), element);
  if (ctkDICOMDataset::CheckCondition(condition))
    {
    std::cerr << "ctkDICOMDataset::findAndGetElement() failed" << std::endl;
    return EXIT_FAILURE;
    }
  OFString string;
  condition = dataset.findAndGetOFString(DcmTag(), string);
  if (ctkDICOMDataset::CheckCondition(condition))
    {
    std::cerr << "ctkDICOMDataset::findAndGetOFString() failed" << std::endl;
    return EXIT_FAILURE;
    }
   try
    {
    QString string = dataset.GetAllElementValuesAsString(DcmTag());
    QString string2 = dataset.GetElementAsString(DcmTag());
    QStringList list = dataset.GetElementAsStringList(DcmTag());
    ctkDICOMPersonName name = dataset.GetElementAsPersonName(DcmTag());
    ctkDICOMPersonNameList nameList = dataset.GetElementAsPersonNameList(DcmTag());
    QDate date = dataset.GetElementAsDate(DcmTag());
    QTime time = dataset.GetElementAsTime(DcmTag());
    double doubleValue = dataset.GetElementAsDouble(DcmTag());
    int integerValue = dataset.GetElementAsInteger(DcmTag());
    int shortValue = dataset.GetElementAsSignedShort(DcmTag());
    int ushortValue = dataset.GetElementAsUnsignedShort(DcmTag());
    QDateTime dateTime = dataset.GetElementAsDateTime(DcmTag());
    Q_UNUSED(string);
    Q_UNUSED(string2);
    Q_UNUSED(list);
    Q_UNUSED(name);
    Q_UNUSED(nameList);
    Q_UNUSED(date);
    Q_UNUSED(time);
    Q_UNUSED(doubleValue);
    Q_UNUSED(integerValue);
    Q_UNUSED(shortValue);
    Q_UNUSED(ushortValue);
    Q_UNUSED(dateTime);

    dataset.SetElementAsString( DcmTag(), QString());
    dataset.SetElementAsStringList( DcmTag(), QStringList() );
    dataset.SetElementAsPersonName( DcmTag(), ctkDICOMPersonName());
    dataset.SetElementAsPersonNameList( DcmTag(), ctkDICOMPersonNameList() );
    dataset.SetElementAsDate( DcmTag(), QDate() );
    dataset.SetElementAsTime( DcmTag(), QTime() );
    dataset.SetElementAsDateTime( DcmTag(), QDateTime() );
    dataset.SetElementAsInteger( DcmTag(), 0 ); // type IS
    dataset.SetElementAsSignedShort( DcmTag(), 0 ); // type SS
    dataset.SetElementAsUnsignedShort( DcmTag(), 0 ); // type US
    }
  catch(...)
    {
    std::cout << "ctkDICOMDataset::GetElementValueAsXXX() throws exceptions"
              << std::endl;
    //return EXIT_FAILURE;
    }
  ctkDICOMDataset::TranslateDefinedTermPatientPosition(QString());
  ctkDICOMDataset::TranslateDefinedTermModality(QString());
  ctkDICOMDataset::TagKey(DcmTag());
  ctkDICOMDataset::TagDescription(DcmTag());
  ctkDICOMDataset::TagVR(DcmTag());
  
  return EXIT_SUCCESS;
}