// Builds a network with a network_spec in the network description // language, to recognize a character set of num_outputs size. // If append_index is non-negative, then *network must be non-null and the // given network_spec will be appended to *network AFTER append_index, with // the top of the input *network discarded. // Note that network_spec is call by value to allow a non-const char* pointer // into the string for BuildFromString. // net_flags control network behavior according to the NetworkFlags enum. // The resulting network is returned via **network. // Returns false if something failed. bool NetworkBuilder::InitNetwork(int num_outputs, STRING network_spec, int append_index, int net_flags, float weight_range, TRand* randomizer, Network** network) { NetworkBuilder builder(num_outputs); Series* bottom_series = NULL; StaticShape input_shape; if (append_index >= 0) { // Split the current network after the given append_index. ASSERT_HOST(*network != NULL && (*network)->type() == NT_SERIES); Series* series = reinterpret_cast<Series*>(*network); Series* top_series = NULL; series->SplitAt(append_index, &bottom_series, &top_series); if (bottom_series == NULL || top_series == NULL) { tprintf("Yikes! Splitting current network failed!!\n"); return false; } input_shape = bottom_series->OutputShape(input_shape); delete top_series; } char* str_ptr = &network_spec[0]; *network = builder.BuildFromString(input_shape, &str_ptr); if (*network == NULL) return false; (*network)->SetNetworkFlags(net_flags); (*network)->InitWeights(weight_range, randomizer); (*network)->SetupNeedsBackprop(false); if (bottom_series != NULL) { bottom_series->AppendSeries(*network); *network = bottom_series; } (*network)->CacheXScaleFactor((*network)->XScaleFactor()); return true; }
bool TestPlotWithArea::DoTest() { Plot *plot; plot = new Plot(); Area *area = new Area2D(); Box *box1, *box2; box1 = new Box(plot); box2 = new Box(plot); Series *series; series = new Series2D("Series"); DataTyped<int> *xdata; xdata = new DataTyped<int>(); series->SetData(xdata, AXIS_X); area->AddSeries(series); plot->AddArea(area); delete box1; delete plot; return true; }
// Parses a network that begins with 'C'. Network* NetworkBuilder::ParseC(const StaticShape& input_shape, char** str) { NetworkType type = NonLinearity((*str)[1]); if (type == NT_NONE) { tprintf("Invalid nonlinearity on C-spec!: %s\n", *str); return nullptr; } int y = 0, x = 0, d = 0; if ((y = strtol(*str + 2, str, 10)) <= 0 || **str != ',' || (x = strtol(*str + 1, str, 10)) <= 0 || **str != ',' || (d = strtol(*str + 1, str, 10)) <= 0) { tprintf("Invalid C spec!:%s\n", *str); return nullptr; } if (x == 1 && y == 1) { // No actual convolution. Just a FullyConnected on the current depth, to // be slid over all batch,y,x. return new FullyConnected("Conv1x1", input_shape.depth(), d, type); } Series* series = new Series("ConvSeries"); Convolve* convolve = new Convolve("Convolve", input_shape.depth(), x / 2, y / 2); series->AddToStack(convolve); StaticShape fc_input = convolve->OutputShape(input_shape); series->AddToStack(new FullyConnected("ConvNL", fc_input.depth(), d, type)); return series; }
void readData() { //percorrendo list<double>::iterator it; for(int i = 0; i < mySeries.size(); i++) { cout <<"serie " << i<<endl; for(it = mySeries[i].begin(); it != mySeries[i].end(); it++) { cout << *it << " "; } cout << endl; } for(int i = 0; i < templateSeries.size(); i++) { cout <<"serie " << i<<endl; for(it = templateSeries[i].begin(); it != templateSeries[i].end(); it++) { cout << *it << " "; } cout << endl; } }
void Talk::cmd_load(mrs_string fname, mrs_natural lineSize) { cout << "cmd_load called" << endl; src_ = new SoundFileSource("src"); src_->updControl("mrs_string/filename", fname); fname_ = fname; src_->updControl("mrs_natural/inSamples", lineSize); AbsMax* absmax = new AbsMax("absmax"); Series *series = new Series("plot"); series->addMarSystem(src_); series->addMarSystem(absmax); mrs_natural hops = src_->getctrl("mrs_natural/size")->to<mrs_natural>() * src_->getctrl("mrs_natural/nChannels")->to<mrs_natural>() / src_->getctrl("mrs_natural/inSamples")->to<mrs_natural>() + 1; Accumulator* acc = new Accumulator("acc"); acc->updControl("mrs_natural/nTimes", hops); acc->addMarSystem(series); realvec in(acc->getctrl("mrs_natural/inObservations")->to<mrs_natural>(), acc->getctrl("mrs_natural/inSamples")->to<mrs_natural>()); realvec out(acc->getctrl("mrs_natural/onObservations")->to<mrs_natural>(), acc->getctrl("mrs_natural/onSamples")->to<mrs_natural>()); acc->process(in,out); out.send(communicator_); // Util util; // fname_ = fname; // src_ = util.sfopen(fname, MRS_SF_READ); // if (src_ == NULL) // cout << "src_ = NULL" << endl; // if (src_ != NULL) // File exists // { // src_->initWindow(lineSize, lineSize, 0, 0); // PlotExtractor pextractor(src_, src_->winSize()); // fvec res(src_->iterations()); // pextractor.extract(0, src_->iterations(), res); // res.send(communicator_); // } // else // { // fvec res(0); // res.send(communicator_); // } }
void LocalService::CheckDataSet( DcmDataset *dataSet, SerieInfo &sInfo, TableRow &row, std::string path) { // load data from dataSet GetTableRowFromDataSet( dataSet, &row); GetSeriesInfo( dataSet, &sInfo); // now check what is in database Patients::iterator patIt = m_patients.find( row.patientID); if( patIt == m_patients.end() ) { // insert new patient // insert new study Serie serie(sInfo.id, sInfo.description, path); Series s; s.insert( Series::value_type( serie.id, serie) ); Study stud(row.studyID, row.date, s); Studies buddStudies; buddStudies.insert( Studies::value_type( stud.id, stud)); Patient buddPat( row.patientID, row.name, row.birthDate, row.sex, buddStudies); m_patients.insert( Patients::value_type( row.patientID, buddPat) ); } else { // perform lookup level down Studies &studies = patIt->second.studies; Studies::iterator studItr = studies.find( row.studyID); if( studItr == studies.end() ) { // insert new study Serie serie(sInfo.id, sInfo.description, path); Series s; s.insert( Series::value_type( serie.id, serie) ); Study stud(row.studyID, row.date, s); patIt->second.studies.insert( Studies::value_type( stud.id, stud) ); } else { // perform lookup level down Series &series = studItr->second.series; Series::iterator serItr = series.find( sInfo.id); if( serItr == series.end() ) { // insert new serie Serie buddy(sInfo.id, sInfo.description, path); series.insert( Series::value_type( sInfo.id, buddy) ); } // else do nothing } } }
DataDictionaryImpl::DataDictionaryImpl(const DataDictionaryImpl& other) : _loadedFieldDictionary(false), _loadedEnumTypeDef(false), _pDictionaryEntryList(0), _pEnumTypeTableList(0), _ownRsslDataDictionary(true), _pfieldNameToIdHash(0) { _errorText.length = MAX_ERROR_TEXT_SIZE; _errorText.data = (char*)malloc(sizeof(char) * _errorText.length); if ( !_errorText.data ) { throwMeeException("Failed to allocate memory in DataDictionaryImpl::DataDictionaryImpl()"); } if ( _ownRsslDataDictionary ) { try { _pRsslDataDictionary = new RsslDataDictionary(); } catch (std::bad_alloc) { throwMeeException("Failed to allocate memory in DataDictionaryImpl::DataDictionaryImpl()"); } rsslClearDataDictionary(_pRsslDataDictionary); } if (!other._loadedEnumTypeDef && !other._loadedFieldDictionary) { return; } Series series; if ( other._loadedFieldDictionary ) { const_cast<DataDictionaryImpl&>(other).encodeFieldDictionary(series, DICTIONARY_VERBOSE); StaticDecoder::setData(&series, 0); decodeFieldDictionary(series, DICTIONARY_VERBOSE); series.clear(); } if ( other._loadedEnumTypeDef ) { const_cast<DataDictionaryImpl&>(other).encodeEnumTypeDictionary(series, DICTIONARY_VERBOSE); StaticDecoder::setData(&series, 0); decodeEnumTypeDictionary(series, DICTIONARY_VERBOSE); } }
void LineChartPane::SetOffset(ViewChannels &channels, int offset){ for (size_t i = 0; i < channels.Count(); i++){ ViewChannel &channel = channels[i]; Series *series = m_lineChart->GetSeries(channel.ToString()); if (NULL != series){ series->SetOffset(offset); } } m_lineChart->Refresh(); }
void perform_test_trivial() { Series s; typedef ParserResultElement<Series> Parser; Parser p(s); { const std::string test = "09/y-i/A/xXyY1"; OKLIB_TESTTRIVIAL_RETHROW(::OKlib::Parser::Test_ParsingString<Parser>(p, test, ::OKlib::Parser::match_full)); if(s.name() != test) OKLIB_THROW("Resulting name is " + s.name() + ", and not " + test); } }
coarse_grain(Series const &series, Discretization discretization, ordered_inserter<Out> out) { typedef typename concepts::TimeSeries<Series const>::offset_type offset_type; BOOST_ASSERT(discretization > series.discretization()); BOOST_ASSERT(discretization % series.discretization() == 0); offset_type factor = discretization / series.discretization(); detail::coarse_grain_inserter<ordered_inserter<Out>, offset_type> o(out, factor); return range_run_storage::copy(series, o).out(); }
void LineChartPane::UpdateValueRange(ViewDataHistoryArray &historyArray, size_t fromIndex, size_t toIndex){ for (size_t i = 0; i < historyArray.size(); i++){ ViewDataHistory &history = historyArray[i]; Series *series = m_lineChart->GetSeries(history.channel.ToString()); if (NULL != series){ for (size_t i = fromIndex; i < toIndex; i++){ series->SetValueAt(i, history.values[i]); } m_lineChart->Refresh(); } } }
// Parses an Output spec. Network* NetworkBuilder::ParseOutput(const StaticShape& input_shape, char** str) { char dims_ch = (*str)[1]; if (dims_ch != '0' && dims_ch != '1' && dims_ch != '2') { tprintf("Invalid dims (2|1|0) in output spec!:%s\n", *str); return nullptr; } char type_ch = (*str)[2]; if (type_ch != 'l' && type_ch != 's' && type_ch != 'c') { tprintf("Invalid output type (l|s|c) in output spec!:%s\n", *str); return nullptr; } int depth = strtol(*str + 3, str, 10); if (depth != num_softmax_outputs_) { tprintf("Warning: given outputs %d not equal to unicharset of %d.\n", depth, num_softmax_outputs_); depth = num_softmax_outputs_; } NetworkType type = NT_SOFTMAX; if (type_ch == 'l') type = NT_LOGISTIC; else if (type_ch == 's') type = NT_SOFTMAX_NO_CTC; if (dims_ch == '0') { // Same as standard fully connected. return BuildFullyConnected(input_shape, type, "Output", depth); } else if (dims_ch == '2') { // We don't care if x and/or y are variable. return new FullyConnected("Output2d", input_shape.depth(), depth, type); } // For 1-d y has to be fixed, and if not 1, moved to depth. if (input_shape.height() == 0) { tprintf("Fully connected requires fixed height!\n"); return nullptr; } int input_size = input_shape.height(); int input_depth = input_size * input_shape.depth(); Network* fc = new FullyConnected("Output", input_depth, depth, type); if (input_size > 1) { Series* series = new Series("FCSeries"); series->AddToStack(new Reconfig("FCReconfig", input_shape.depth(), 1, input_shape.height())); series->AddToStack(fc); fc = series; } return fc; }
void LocalService::FindStudyInfo( SerieInfoVector &result, const std::string &patientID, const std::string &studyID) { // just take informatoin from tree Series series = GetSeries( patientID, studyID); SerieInfo s; for( Series::iterator serie=series.begin(); serie != series.end(); serie++) { s.id = serie->second.id; s.description = serie->second.desc; result.push_back( s); } }
bool TestSeries2DwithData::DoTest() { Series *serie; serie = new Series2D("new series"); DataNoType *xdata, *ydata; xdata = new DataTyped<double>(100, "x-data"); ydata = new DataTyped<double>(100, "y-data"); serie->SetData(xdata, AXIS_X); serie->SetData(ydata, AXIS_Y); //delete ydata; delete xdata; delete serie; return true; }
int main() { //threaded try { Series test ("/title/tt0436992/"); test.getEpisodes(); std::cout << test.getXML(); } catch (const char* msg) { std::cerr << msg << std::endl; } }
void LineChartPane::SetBufferSize(ViewChannels &channels, size_t size, int offset){ ViewChannels enabledChannels; for (size_t i = 0; i < channels.Count(); i++){ ViewChannel &channel = channels[i]; Series *series = m_lineChart->GetSeries(channel.ToString()); if (NULL != series){ enabledChannels.Add(channel); series->SetBufferSize(size); series->SetOffset(offset); } } wxCommandEvent addEvent(REQUEST_DATALOG_DATA_EVENT, ID_REQUEST_DATALOG_DATA); RequestDatalogRangeParams *params = new RequestDatalogRangeParams(this, enabledChannels, 0, size - 1); addEvent.SetClientData(params); GetParent()->GetEventHandler()->AddPendingEvent(addEvent); }
void LineChart::DrawCurrentValues(wxMemoryDC &dc, size_t dataIndex, int x, int y){ int currentOffset = 0; wxFont labelFont = GetFont(); int labelWidth,labelHeight,descent,externalLeading; for (SeriesMap::iterator it = m_seriesMap.begin(); it != m_seriesMap.end(); ++it){ Series *series = it->second; double dataValue = series->GetValueAtOrNear(dataIndex); wxString numberFormat = "% 2." + wxString::Format("%df", series->GetPrecision()); wxString valueString = (DatalogValue::NULL_VALUE == dataValue ? "---" : wxString::Format(numberFormat.ToAscii(), dataValue)) + " " + series->GetLabel(); dc.SetTextForeground(series->GetColor()); dc.GetTextExtent(valueString, &labelHeight, &labelWidth, &descent, &externalLeading, &labelFont); dc.DrawRotatedText(valueString, x + CURRENT_VALUES_RIGHT_OFFSET, y + currentOffset,0); currentOffset += labelWidth; } }
const Series operator/(const double ÷nd, const Series &series) { Series returnSeries(series); for (auto &datetime_series : returnSeries.datetime_map_) { for (auto &sample : datetime_series.second.series_) { sample.value = dividend / sample.value; } } returnSeries.SetName("(" + std::to_string(dividend) + " / " + series.GetName() + ")"); return returnSeries; }
void DTW() { int myBestClass; double myMinDbl, myDbl; int totalHits, correctClass; list<double>::iterator it; totalHits = 0; //uncoment do get graph data //cout << " Error at: \n Serie number | Class Estimated | Correct Class " << endl; //series a serem testadas for(int k = 0; k < mySeries.size()-1; k++) { myMinDbl = INFINITY; //series templates for(int i = 0; i < templateSeries.size() -1; i++) { myDbl = calcDTW(k, i); if(myDbl < myMinDbl) { it = templateSeries[i].begin(); myBestClass = *it; myMinDbl = myDbl; } } it = mySeries[k].begin(); correctClass = *it; if(myBestClass == correctClass)totalHits++; // else cout << k << " " << myBestClass << " " << correctClass << endl; } cout <<"Total de Séries: "<< mySeries.size() -1 <<"\nacertos: " << totalHits <<" -> " << std::setprecision(5)<< (totalHits * 100.0)/(mySeries.size() -1) << "%" <<endl; }
// Helper builds a truly (0-d) fully connected layer of the given type. static Network* BuildFullyConnected(const StaticShape& input_shape, NetworkType type, const STRING& name, int depth) { if (input_shape.height() == 0 || input_shape.width() == 0) { tprintf("Fully connected requires positive height and width, had %d,%d\n", input_shape.height(), input_shape.width()); return nullptr; } int input_size = input_shape.height() * input_shape.width(); int input_depth = input_size * input_shape.depth(); Network* fc = new FullyConnected(name, input_depth, depth, type); if (input_size > 1) { Series* series = new Series("FCSeries"); series->AddToStack(new Reconfig("FCReconfig", input_shape.depth(), input_shape.width(), input_shape.height())); series->AddToStack(fc); fc = series; } return fc; }
void Talk::cmd_play(mrs_natural start, mrs_natural end, mrs_natural lineSize) { communicator_->send_message("From Server: Play command received\n"); src_->updControl("mrs_natural/pos", (mrs_natural)start * lineSize); src_->updControl("mrs_natural/inSamples", lineSize); Series *series = new Series("playbacknet"); series->addMarSystem(src_); series->addMarSystem(dest_); series->updControl("AudioSink/dest/mrs_natural/nChannels", series->getctrl("SoundFileSource/src/mrs_natural/nChannels")->to<mrs_natural>()); for (int i=0; i < end-start; ++i) { series->tick(); // communicator_->send_message("tick\n"); } }
// Parses a sequential series of networks, defined by [<net><net>...]. Network* NetworkBuilder::ParseSeries(const StaticShape& input_shape, Input* input_layer, char** str) { StaticShape shape = input_shape; Series* series = new Series("Series"); ++*str; if (input_layer != nullptr) { series->AddToStack(input_layer); shape = input_layer->OutputShape(shape); } Network* network = NULL; while (**str != '\0' && **str != ']' && (network = BuildFromString(shape, str)) != NULL) { shape = network->OutputShape(shape); series->AddToStack(network); } if (**str != ']') { tprintf("Missing ] at end of [Series]!\n"); delete series; return NULL; } ++*str; return series; }
void DataDictionaryImpl::decodeEnumTypeDictionary(const Series& series, UInt32 verbosity) { if (_ownRsslDataDictionary) { RsslBuffer rsslBuffer; rsslBuffer.data = (char *)series.getAsHex().c_buf(); rsslBuffer.length = series.getAsHex().length(); RsslDecodeIterator rsslDecodeIterator; rsslClearDecodeIterator(&rsslDecodeIterator); RsslRet ret; if ((ret = rsslSetDecodeIteratorBuffer(&rsslDecodeIterator, &rsslBuffer)) != RSSL_RET_SUCCESS) { throwIueException("Failed to set decode iterator buffer in DataDictionaryImpl::decodeEnumTypeDictionary()"); } if ((ret = rsslSetDecodeIteratorRWFVersion(&rsslDecodeIterator, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION)) != RSSL_RET_SUCCESS) { throwIueException("Failed to set decode iterator RWF version in DataDictionaryImpl::decodeEnumTypeDictionary()"); } if (rsslDecodeEnumTypeDictionary(&rsslDecodeIterator, _pRsslDataDictionary, (RDMDictionaryVerbosityValues)verbosity, &_errorText) < 0) { EmaString errorText("Failed to decode the enumerated types dictionary"); errorText.append(CR).append("Reason='").append(_errorText.data).append("'"); throwIueException(errorText); } _loadedEnumTypeDef = true; } else { throwIueForQueryOnly(); } }
// plot a new curve, if a figure of the specified figure name already exists, // the curve will be plot on that figure; if not, a new figure will be created. void PlotManager::Plot(const string figure_name, const float *p, int count, int step, int R, int G, int B) { if (count < 1) return; if (step <= 0) step = 1; // copy data and create a series format. float *data_copy = new float[count]; for (int i = 0; i < count; i++) *(data_copy + i) = *(p + step * i); Series s; s.SetData(count, data_copy); if ((R > 0) || (G > 0) || (B > 0)) s.SetColor(R, G, B, false); // search the named window and create one if none was found active_figure = FindFigure(figure_name); if ( active_figure == NULL) { Figure new_figure(figure_name); figure_list.push_back(new_figure); active_figure = FindFigure(figure_name); if (active_figure == NULL) exit(-1); } active_series = active_figure->Add(s); active_figure->Show(); }
void DataDictionaryImpl::encodeEnumTypeDictionary(Series& series, UInt32 verbosity) { if (!_loadedEnumTypeDef) { throwIueException("The enumerated types dictionary was not loaded"); } SeriesEncoder& seriesEncoder = static_cast<SeriesEncoder&>(const_cast<Encoder&>(series.getEncoder())); UInt32 enumTypeDictionarySize = _pRsslDataDictionary->enumTableCount > 0 ? (_pRsslDataDictionary->enumTableCount * DEFAULT_ENUM_TABLE_ENTRY_SIZE ) : DEFAULT_ENCODE_ITERATOR_BUFFER_SIZE; EncodeIterator* pEncodeIterator; if (!seriesEncoder.hasEncIterator()) { seriesEncoder.acquireEncIterator(enumTypeDictionarySize); pEncodeIterator = seriesEncoder._pEncodeIter; } else { pEncodeIterator = seriesEncoder._pEncodeIter; pEncodeIterator->clear(enumTypeDictionarySize); } RsslRet ret; while ((ret = rsslEncodeEnumTypeDictionary(&pEncodeIterator->_rsslEncIter, _pRsslDataDictionary, (RDMDictionaryVerbosityValues)verbosity, &_errorText)) == RSSL_RET_DICT_PART_ENCODED) { pEncodeIterator->reallocate(pEncodeIterator->_allocatedSize * 2); } if (ret != RSSL_RET_SUCCESS) { thomsonreuters::ema::access::EmaString errorText("Failed to encode the enumerated type definition"); errorText.append(CR).append("Reason='").append(_errorText.data).append("'"); throwIueException(errorText); } pEncodeIterator->setEncodedLength(rsslGetEncodedBufferLength(&(pEncodeIterator->_rsslEncIter))); seriesEncoder._containerComplete = true; }
rotate_left(Series const &series, typename concepts::TimeSeries<Series const>::value_type const &value) { typedef typename concepts::TimeSeries<Series const>::value_type value_type; typedef typename concepts::TimeSeries<Series const>::discretization_type discretization_type; typedef typename concepts::TimeSeries<Series const>::offset_type offset_type; // The partial differences are held in a sparse array. sparse_series<value_type, discretization_type, offset_type> result( time_series::discretization = series.discretization() ); time_series::rotate_left( series , value , time_series::make_ordered_inserter(result) ).commit(); return result; }
period_sums(Series const &series, Offset start, Length length) { typedef typename concepts::TimeSeries<Series const>::value_type value_type; typedef typename concepts::TimeSeries<Series const>::discretization_type discretization_type; // The periodic sums are held in a sparse array. The sums are // stored at the start of their associated periods. sparse_series<value_type, discretization_type, Offset> result( time_series::discretization = series.discretization() ); time_series::period_sums( series , start , length , time_series::make_ordered_inserter(result) ).commit(); return result; }
Volume* VolumeBuilderFromCaptures::build() { Q_ASSERT(m_parentStudy); Q_ASSERT(m_vtkImageAppend->GetNumberOfInputs()); // Creem la nova sèrie Series *newSeries = new Series(); // Omplim la informació de la sèrie a partir de la sèrie de referència // Assignem la modalitat segons el valor introduit. El valor per defecte és 'OT' (Other). newSeries->setModality(m_modality); newSeries->setSOPClassUID(QString(UID_SecondaryCaptureImageStorage)); // Generem el SeriesInstanceUID a partir del generador de DCMTK. \TODO Utilitzar el nostre UID_ROOT? char seriesUid[100]; dcmGenerateUniqueIdentifier(seriesUid, SITE_SERIES_UID_ROOT); newSeries->setInstanceUID(QString(seriesUid)); // \TODO Quin criteri volem seguir per donar nous noms? newSeries->setSeriesNumber(QString("0000") + QString::number(m_parentStudy->getSeries().count())); newSeries->setDescription(this->getSeriesDescription()); // Assignem la sèrie a l'estudi al qual partenyia l'inputVolume. newSeries->setParentStudy(m_parentStudy); m_parentStudy->addSeries(newSeries); // Obtenim el nou vtkImageData a partir de la sortida del vtkImageAppend. // Fem un flip horitzontal per tal utilitzar el mateix sistema de coordenades que DICOM. m_vtkImageAppend->Update(); vtkSmartPointer<vtkImageData> newVtkData = vtkSmartPointer<vtkImageData>::New(); newVtkData->ShallowCopy(m_vtkImageAppend->GetOutput()); // Creem el nou volume Volume *newVolume = new Volume(); newSeries->addVolume(newVolume); // Generem les noves imatges a partir del vtkData generat per vtkImageAppend int samplesPerPixel = newVtkData->GetNumberOfScalarComponents(); int bitsAllocated; int bitsStored; int highBit; int pixelRepresentation; int rows; int columns; // \TODO Potser podriem ser mes precisos QString photometricInterpretation; if (samplesPerPixel == 1) { photometricInterpretation = QString("MONOCHROME2"); } else if (samplesPerPixel == 3) { photometricInterpretation = QString("RGB"); } int scalarType = newVtkData->GetScalarType(); switch (scalarType) { //case VTK_CHAR: //break; case VTK_SIGNED_CHAR: bitsAllocated = 8; pixelRepresentation = 1; break; case VTK_UNSIGNED_CHAR: bitsAllocated = 8; pixelRepresentation = 0; break; case VTK_SHORT: bitsAllocated = 16; pixelRepresentation = 1; break; case VTK_UNSIGNED_SHORT: bitsAllocated = 16; pixelRepresentation = 0; break; case VTK_INT: bitsAllocated = 32; pixelRepresentation = 1; break; case VTK_UNSIGNED_INT: bitsAllocated = 32; pixelRepresentation = 0; break; // case VTK_FLOAT: // bitsAllocated = 32; // pixelRepresentation = 1; ? // break; // case VTK_DOUBLE: // bitsAllocated = 64; // pixelRepresentation = 1; ? // break; default: DEBUG_LOG(QString("Pixel Type no suportat: ") + newVtkData->GetScalarTypeAsString()); } bitsStored = bitsAllocated; highBit = bitsStored - 1; int *dimensions = newVtkData->GetDimensions(); double *spacing = newVtkData->GetSpacing(); rows = dimensions[1]; columns = dimensions[0]; Image *currentImage; for (int i = 0; i < dimensions[2]; i++) { currentImage = new Image(); // Generem el SOPInstanceUID a partir del generador de DCMTK. \TODO Utilitzar el nostre UID_ROOT? char instanceUid[100]; dcmGenerateUniqueIdentifier(instanceUid, SITE_INSTANCE_UID_ROOT); currentImage->setSOPInstanceUID(QString(instanceUid)); newSeries->addImage(currentImage); newVolume->addImage(currentImage); currentImage->setParentSeries(newSeries); currentImage->setOrderNumberInVolume(i); currentImage->setVolumeNumberInSeries(0); currentImage->setBitsAllocated(bitsAllocated); currentImage->setBitsStored(bitsStored); currentImage->setHighBit(highBit); currentImage->setColumns(columns); currentImage->setInstanceNumber(QString::number(i + 1)); currentImage->setPhotometricInterpretation(photometricInterpretation); currentImage->setPixelRepresentation(pixelRepresentation); currentImage->setPixelSpacing(spacing[0], spacing[1]); currentImage->setRows(rows); currentImage->setSamplesPerPixel(samplesPerPixel); } // Es fa després d'haver inserit les imatges perquè el nou Volume activi el flag de dades carregades. newVolume->setData(newVtkData); newVolume->setNumberOfPhases(1); newVolume->setNumberOfSlicesPerPhase(newSeries->getImages().count()); // Informació de DEBUG DEBUG_LOG(QString("\nNova sèrie generada:") + QString("\n SeriesInstanceUID: ") + newSeries->getInstanceUID() + QString("\n SeriesNumber: ") + newSeries->getSeriesNumber() + QString("\n SeriesDescription: ") + newSeries->getDescription() + QString("\n SOPClassUID: ") + newSeries->getSOPClassUID() + QString("\n Modality: ") + newSeries->getModality() + QString("\n SamplesPerPixel: ") + QString::number(samplesPerPixel) + QString("\n PhotometricInterpretation: ") + photometricInterpretation + QString("\n BitsAllocated: ") + QString::number(bitsAllocated) + QString("\n BitsStored: ") + QString::number(bitsStored) + QString("\n HighBit: ") + QString::number(highBit) + QString("\n PixelRepresentation: ") + QString::number(pixelRepresentation) + QString("\n PixelSpacing: ") + QString::number(spacing[0]) + QString(",") + QString::number(spacing[1]) + QString("\n Num.Imatges: ") + QString::number(newSeries->getImages().count())); return newVolume; }
int LineChart::DrawScale(wxMemoryDC &dc){ int leftOrientationEdge = 0; int rightOrientationEdge = _currentWidth - 1; int scaleOrientation = LineChart::ORIENTATION_LEFT; wxFont labelFont = GetFont(); int tickLabelWidth = 0; for (SeriesMap::iterator it = m_seriesMap.begin(); it != m_seriesMap.end(); ++it){ int maxLabelWidth = 0; Series *series = it->second; Range * range = m_rangeArray[series->GetRangeId()]; double minValue = range->GetMin(); double maxValue = range->GetMax(); double rangeSize = maxValue - minValue; double stepInterval = (maxValue - minValue) / 10; if (stepInterval == 0) stepInterval = 1; dc.SetPen(*wxThePenList->FindOrCreatePen(series->GetColor(), 1, wxSOLID)); dc.SetTextForeground(series->GetColor()); bool labelOn = false; int tickLabelHeight,tickDescent,tickExternalLeading; dc.DrawLine(leftOrientationEdge, 0, leftOrientationEdge, _currentHeight); for (double tick = minValue; tick <=maxValue; tick += stepInterval){ int y = _currentHeight - (double)_currentHeight * ((tick - minValue) / rangeSize); int nextY = _currentHeight - (double)_currentHeight * ((tick + stepInterval - minValue) / rangeSize); if (labelOn){ wxString numberFormat = "%." + wxString::Format("%df", range->GetPrecision()); wxString tickLabel = wxString::Format(numberFormat, tick); dc.GetTextExtent(tickLabel, &tickLabelHeight, &tickLabelWidth, &tickDescent, &tickExternalLeading, &labelFont); if (tickLabelHeight > maxLabelWidth) maxLabelWidth = tickLabelHeight; if (tickLabelWidth < y - nextY ){ switch (scaleOrientation){ case LineChart::ORIENTATION_LEFT: { dc.DrawRotatedText(tickLabel, leftOrientationEdge, y, 0); break; } case LineChart::ORIENTATION_RIGHT: { dc.DrawRotatedText(tickLabel, rightOrientationEdge, y, 0); break; } } } } labelOn = !labelOn; dc.DrawLine(leftOrientationEdge, y, leftOrientationEdge + tickLabelWidth, y); } maxLabelWidth+=(tickLabelWidth / 2); switch (scaleOrientation){ case LineChart::ORIENTATION_LEFT: { leftOrientationEdge += (maxLabelWidth); break; } case LineChart::ORIENTATION_RIGHT: { rightOrientationEdge -= (maxLabelWidth); break; } } } return leftOrientationEdge; }
void LineChart::OnPaint(wxPaintEvent &event){ wxPaintDC old_dc(this); float zoomFactor = (float)_zoomPercentage / 100; int w,h ; GetClientSize(&w,&h); if (w != _currentWidth || h != _currentHeight){ delete (_memBitmap); _currentWidth = w; _currentHeight = h; _memBitmap = new wxBitmap(_currentWidth, _currentHeight); } ///////////////// // Create a memory DC wxMemoryDC dc; dc.SelectObject(*_memBitmap); wxColor backColor = GetBackgroundColour(); dc.SetBackground(*wxTheBrushList->FindOrCreateBrush(backColor,wxSOLID)); dc.SetBrush(*wxTheBrushList->FindOrCreateBrush(backColor,wxSOLID)); dc.Clear(); DrawGrid(dc); if (m_showScale){ m_leftEdge = DrawScale(dc); } else{ m_leftEdge = 0; } size_t largestBufferSize = GetMaxSeriesBufferSize(); double lastValue = 0; for (SeriesMap::iterator it = m_seriesMap.begin(); it != m_seriesMap.end(); ++it){ float currentX = (float)m_leftEdge; int lastX = (int)currentX; int lastY; Series *series = it->second; dc.SetPen(*wxThePenList->FindOrCreatePen(series->GetColor(), 1, wxSOLID)); size_t bufSize = series->GetBufferSize(); Range *range = m_rangeArray[series->GetRangeId()]; if (bufSize > 0){ double minValue = range->GetMin(); double maxValue = range->GetMax(); double loggedValue = series->GetValueAt(0); double percentageOfMax = (loggedValue - minValue) / (maxValue - minValue); lastY = h - (int)(((double)h) * percentageOfMax); size_t i = (size_t)(((double)largestBufferSize) * m_viewOffsetFactor); while (i < bufSize && currentX < _currentWidth ){ if (i == m_markerIndex){ wxPen pen = dc.GetPen(); dc.SetPen(*wxThePenList->FindOrCreatePen(*wxLIGHT_GREY, 1, wxSOLID)); dc.DrawLine(currentX, 0, currentX, _currentHeight); DrawCurrentValues(dc, i, currentX, CURRENT_VALUES_TOP_OFFSET); dc.SetPen(pen); } loggedValue = series->GetValueAt(i); if (DatalogValue::NULL_VALUE == loggedValue){ loggedValue = lastValue; } else{ lastValue = loggedValue; } double percentageOfMax = (loggedValue - minValue) / (maxValue - minValue); int y = h - (int)(((double)h) * percentageOfMax); dc.DrawLine(lastX, lastY, (int)currentX, y); lastX = (int)currentX; lastY = y; currentX += zoomFactor; i++; } } } if (m_showData) DrawMouseoverMarker(dc); //blit into the real DC old_dc.Blit(0,0,_currentWidth,_currentHeight,&dc,0,0); }