bool XSqlQuery::previous()
{
if (!_data)
return QSqlQuery::previous();
bool returnVal = false;
if (_data->_keepTotals && isValid())
{
QMap<QString,double> delta;
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
delta[mit.key()] = value(mit.key()).toDouble();
}
returnVal = QSqlQuery::previous();
if (returnVal)
{
mit = delta;
while(mit.hasNext())
{
mit.next();
_data->_fieldTotals[mit.key()] -= mit.value();
_data->_fieldSubTotals[mit.key()] -= mit.value();
}
}
}
else
returnVal = QSqlQuery::previous();
_data->_currRecord = record();
return returnVal;
}
void
PlotWidget::saveMarkers (DataBase &db)
{
// save plot markers
QHashIterator<QString, Plot *> pit(_plots);
while (pit.hasNext())
{
pit.next();
Plot *p = pit.value();
QHash<QString, Marker *> markers = p->markers();
QHashIterator<QString, Marker *> mit(markers);
while (mit.hasNext())
{
mit.next();
Marker *m = mit.value();
if (m->readOnly())
continue;
if (! m->modified())
continue;
Entity *e = m->settings();
e->setName(mit.key());
db.transaction();
db.set(e);
db.commit();
m->setModified(FALSE);
}
}
}
void DesktopConfigDbBackend::init()
{
m_manager->reset();
m_currentOid = 1;
//KSimpleConfig config( m_fileName ); // DEPRECATED KDE3 -> KDE4 by Percy
KConfig config( m_fileName );
QStringList groups = config.groupList();
QStringList::ConstIterator it( groups.begin() );
QStringList::ConstIterator end( groups.end() );
QMap<QString,QString> map;
for ( ; it != end; ++it ) {
map = config.entryMap( *it );
ObjectRef<Object> obj;
if ( map.contains( "oid" ) )
obj = Classes::classInfo( *it )->create( stringToOid( map["oid"] ), m_manager, true );
else
obj = Classes::classInfo( *it )->create( m_manager );
assert( obj );
if ( m_currentOid < obj->oid() )
m_currentOid = obj->oid();
//QMapConstIterator<QString,QString> mit( map.begin() ); // DEPRECATED Qt3 -> Qt4 by Percy
//QMapConstIterator<QString,QString> mend( map.end() ); // DEPRECATED Qt3 -> Qt4 by Percy
QMap<QString, QString>::const_iterator mit( map.begin() );
QMap<QString, QString>::const_iterator mend( map.end() );
for ( ; mit != mend; ++mit ) {
if ( mit.key() != "oid" )
//obj->setProperty( mit.key(), mit.data() ); // DEPRECATED Qt3 -> Qt4 by Percy
obj->setProperty( mit.key().toAscii(), QVariant(mit.value()) );
}
}
}
void MInput::flush(void)
{
// keys
map<string, int>::iterator
mit (m_keys.begin()),
mend(m_keys.end());
for(; mit!=mend; mit++)
{
if(mit->second == 1)
mit->second = 2;
else if(mit->second == 3)
mit->second = 0;
}
// axis
unsigned int a, aSize = m_axisToFlush.size();
for(a=0; a<aSize; a++)
(*m_axisToFlush[a]) = 0;
// touches
map<int, TouchData>::iterator
t_it(m_touches.begin()),
t_end(m_touches.end());
for(; t_it!=t_end; t_it++)
{
TouchData* data = &(t_it->second);
data->phase = M_TOUCH_NONE;
data->touchPoint = MVector2(0.0f);
}
}
void RAS_BucketManager::OrderBuckets(const MT_Transform& cameratrans, BucketList& buckets, vector<sortedmeshslot>& slots, bool alpha)
{
BucketList::iterator bit;
list<RAS_MeshSlot>::iterator mit;
size_t size = 0, i = 0;
/* Camera's near plane equation: pnorm.dot(point) + pval,
* but we leave out pval since it's constant anyway */
const MT_Vector3 pnorm(cameratrans.getBasis()[2]);
for (bit = buckets.begin(); bit != buckets.end(); ++bit)
{
SG_DList::iterator<RAS_MeshSlot> mit((*bit)->GetActiveMeshSlots());
for(mit.begin(); !mit.end(); ++mit)
size++;
}
slots.resize(size);
for (bit = buckets.begin(); bit != buckets.end(); ++bit)
{
RAS_MaterialBucket* bucket = *bit;
RAS_MeshSlot* ms;
// remove the mesh slot form the list, it culls them automatically for next frame
while((ms = bucket->GetNextActiveMeshSlot())) {
slots[i++].set(ms, bucket, pnorm);
}
}
if(alpha)
sort(slots.begin(), slots.end(), backtofront());
else
sort(slots.begin(), slots.end(), fronttoback());
}
bool XSqlQuery::prev()
{
if (!_data)
return QSqlQuery::prev();
QMap<QString,double> delta;
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
delta[mit.key()] = value(mit.key()).toDouble();
}
if (QSqlQuery::prev())
{
mit = delta;
while(mit.hasNext())
{
mit.next();
_data->_fieldTotals[mit.key()] -= mit.value();
_data->_fieldSubTotals[mit.key()] -= mit.value();
}
return TRUE;
}
return FALSE;
}
void File::addEntity(Entity* entity)
{
map<string, Entity*>* entities;
if (entity != NULL)
{
entities = entity->getEntities();
if ( entities != NULL)
{
map<std::string,Entity*>::const_iterator
mit (entities->begin()),
mend(entities->end());
for(; mit!=mend; ++mit)
{
if (mit->second->getIP() != NULL)
{
deploysOn.push_back(mit->second);
mit->second->addDeploymentState(0, this, OFFLINE);
}
if (mit->second->getEntities() != NULL)
addEntity(mit->second);
}
} else
{
deploysOn.push_back(entity);
entity->addDeploymentState(0, this, OFFLINE);
}
}
}
void GadWorkspace::genMenu()
{
qDebug("GadWorkspace::genMenu\n");
if (!menubar_) {
QtGui *mainmenu = (QtGui *) (*(_qtguiappl->classDict()))["mainmenu"];
if (mainmenu) {
QWidget *w = mainmenu->widget();
if (w && w->inherits("QMenuBar"))
menubar_ = (QMenuBar *) w;
}
}
const ClassDict & classDict = *classDict_;
int size = 0;
QStringList classList;
QDictIterator < ModuleDict > cit(classDict);
for (; cit.current(); ++cit) {
size += cit.current()->count();
classList += cit.currentKey();
}
if (classNameMenu_)
delete classNameMenu_;
classNameMenu_ = new ClassNameMenu[size];
if (popup_)
delete popup_;
popup_ = new QPopupMenu(0);
classList.sort();
QStringList::Iterator c**t;
int item = 0;
for (c**t = classList.begin(); c**t != classList.end(); ++c**t) {
qDebug("Class %s\n", (const char *) *c**t);
QPopupMenu *popup = new QPopupMenu();
popup_->insertItem(*c**t, popup);
connect(popup, SIGNAL(activated(int)), this, SLOT(newObjectSlot(int)));
ModuleDict *moduleDict = classDict[*c**t];
QDictIterator < GadModule > mit(*moduleDict);
QStringList moduleList;
qDebug("test\n");
for (; mit.current(); ++mit)
moduleList += mit.currentKey();
moduleList.sort();
QStringList::Iterator mlit;
qDebug("test\n");
for (mlit = moduleList.begin(); mlit != moduleList.end(); ++mlit) {
qDebug("item=%d\n", item);
classNameMenu_[item].className = *c**t;
classNameMenu_[item].name = *mlit;
popup->insertItem(*mlit, item++);
// popup->insertItem(*mlit,this,SLOT(genNewObject(int)),0,item);
qDebug("test\n");
}
}
if (menubar_)
popupId_ = menubar_->insertItem("&Glyphs", popup_);
qDebug(" connecting with mainMenu\n");
// _qtguiappl->insertClass("classmenu",popup_);
}
void BL_DeformableGameObject::SetDeformer(class RAS_Deformer* deformer)
{
m_pDeformer = deformer;
SG_QList::iterator<RAS_MeshSlot> mit(m_meshSlots);
for (mit.begin(); !mit.end(); ++mit)
{
(*mit)->SetDeformer(deformer);
}
}
bool tGraph::drawPoints() {
//return _drawPoints;
QMapIterator<int, ORStyleData> mit(_setStyle);
while(mit.hasNext())
{
mit.next();
if(mit.value().point) return TRUE;
}
return FALSE;
}
bool tGraph::drawLines() {
//return _drawLines;
QMapIterator<int, ORStyleData> mit(_setStyle);
while(mit.hasNext())
{
mit.next();
if(mit.value().line) return true;
}
return false;
}
void XSqlQuery::resetSubTotals()
{
if (_data)
{
// initial all our values to 0.0
QMapIterator<QString,double> mit(_data->_fieldSubTotals);
while(mit.hasNext())
{
mit.next();
_data->_fieldSubTotals[mit.key()] = 0.0;
}
}
}
void XSqlQuery::resetSubTotalsCurrent()
{
if (_data)
{
// initial all our values to the absolute value of the current record
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
_data->_fieldSubTotals[mit.key()] = value(mit.key()).toDouble();
}
}
}
/**
*
* @param servers QList<QVariant> <=> QList<QMap<QSring, QMap<QString, QVarian> > >
*/
bool TaskServerModel::setData(QVariantList &servers)
{
// check for servers.count()'s value, if 0, no operation needed
if (servers.count() == 0) {
return false;
}
this->mRawServers = servers;
QList<QMap<char, QString> > tServers;
QMap<char, QString> tServer;
QString serverIndex;
QMap<QString, QVariant> server;
QListIterator<QVariant> lit(servers);
int i = 0;
while(lit.hasNext()) {
server = lit.next().toMap();
serverIndex = server[QString("index")].toString();
int sn = 0;
QListIterator<QVariant> mit(server["servers"].toList());
while(mit.hasNext()) {
QMap<QString, QVariant> nServer = mit.next().toMap();
tServer[1] = nServer["downloadSpeed"].toString();
tServer[2] = QUrl(nServer["currentUri"].toString()).host();
tServer[3] = nServer["currentUri"].toString();
tServer[0] = QString("%1-%2").arg(serverIndex).arg(++sn);
tServers.append(tServer);
tServer.clear();
}
}
if (this->mServers.count() > 0) {
this->removeRows(0, this->mServers.count());
}
if (tServers.count() > 0) {
// if no this if, than below warning will show.
// QTreeView::rowsInserted internal representation of the model has been corrupted, resetting.
this->beginInsertRows(QModelIndex(), 0, tServers.count());
this->mServers = tServers;
this->endInsertRows();
}
return true;
}
int main() {
QList<int> intlist;
intlist << 2 << 5 << 2 << 4 << 2;
QMutableListIterator<int> mit(intlist);
mit.toBack();
mit.insert(2);
qDebug() << intlist; // output: (2, 5, 2, 4, 2, 2)
int findings = 0;
while (mit.findPrevious(2))
findings++;
qDebug() << findings; // output: 4
return 0;
}
/** Reimplementation. */
void CLexiconKeyChooser::refreshContent() {
if (m_modules.count() == 1) {
m_widget->reset(&m_modules.first()->entries(), 0, true);
// qWarning("resetted");
}
else {
using EntryMap = std::multimap<unsigned int, QStringList const *>;
EntryMap entryMap;
QListIterator<const CSwordLexiconModuleInfo*> mit(m_modules);
while (mit.hasNext()) {
const QStringList &entries = mit.next()->entries();
entryMap.insert( std::make_pair(entries.count(), &entries) );
}
QStringList goodEntries; //The string list which contains the entries which are available in all modules
EntryMap::iterator it = entryMap.begin(); //iterator to go thoigh all selected modules
QStringList refEntries = *(it->second); //copy the items for the first time
const QStringList *cmpEntries = (++it)->second; //list for comparision, starts with the second module in the map
// Testing for refEntries being empty is not needed for the set union
// of all keys, but is a good idea since it is being updated in the
// loop. It is necessary for set intersection and prevents a crash.
while (it != entryMap.end() && (refEntries.begin() != refEntries.end())) {
std::set_union(
refEntries.begin(), --(refEntries.end()), //--end() is the last valid entry
cmpEntries->begin(), --(cmpEntries->end()),
std::back_inserter(goodEntries), //append valid entries to the end of goodEntries
my_cmpEntries //ci_cmpEntries is the comparision function
);
cmpEntries = ( ++it )->second; //this is a pointer to the string list of a new module
/*
* use the good entries for next comparision,
* because the final list can only have the entries of goodEntries as maxiumum
*/
refEntries = goodEntries;
};
m_widget->reset(goodEntries, 0, true); //write down the entries
} //end of ELSE
}
void Similarity::computeSimilarity() {
std::cout << "Computing similarity scores." << std::endl;
for (unsigned int i = 0; i < ptrOOD->getSize(); i++) {
std::map<std::string, int> tmpTF;
for (unsigned int j = 0; j < ptrVecWords->size(); j++) {
tmpTF[ptrVecWords->operator[](j)] = 0;
}
std::vector<std::string> lWords;
std::string line = ptrOOD->getLine(i);
boost::split(lWords, line, boost::is_any_of(" "));
for (unsigned int j = 0; j < lWords.size(); j++) {
std::map<std::string, int>::const_iterator mit(tmpTF.find(lWords[j])), mend(tmpTF.end());
if(mit != mend)
tmpTF[lWords[j]] = tmpTF[lWords[j]] + 1;
}
float sumAiBi = 0.0;
float sumAiSQ = 0.0;
float sumBiSQ = 0.0;
for (unsigned int j = 0; j < ptrVecWords->size(); j++) {
float oodTfIdf = (float)tmpTF[ptrVecWords->operator[](j)] * (float)ptrOodVecIdf->operator[](j);
float idTfIdf = ptrIdVecTfIdf->operator[](j);
sumAiBi = sumAiBi + (idTfIdf * oodTfIdf);
sumAiSQ = sumAiSQ + (idTfIdf * idTfIdf);
sumBiSQ = sumBiSQ + (oodTfIdf * oodTfIdf);
}
float sim = sumAiBi / (sqrt(sumAiSQ) * sqrt(sumBiSQ));
/** @bug Sometimes sim = NaN, so we need to protect against that */
if (sim != sim)
sim = 0.0;
ptrOodSimilarity->operator[](i) = sim;
}
std::cout << "Done computing similarity scores." << std::endl;
}
bool XSqlQuery::next()
{
if (QSqlQuery::next())
{
if (_data)
{
// increment all our values
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
_data->_fieldTotals[mit.key()] += value(mit.key()).toDouble();
_data->_fieldSubTotals[mit.key()] += value(mit.key()).toDouble();
}
}
return TRUE;
}
return FALSE;
}
bool XSqlQuery::first()
{
if (QSqlQuery::first())
{
if (_data)
{
// initial all our values
resetSubTotals();
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
_data->_fieldTotals[mit.key()] = value(mit.key()).toDouble();
_data->_fieldSubTotals[mit.key()] = value(mit.key()).toDouble();
}
}
return TRUE;
}
return FALSE;
}
void nl80211::receive_handler(const boost::system::error_code& ec, size_t rbytes)
{
if (ec) {
_event_handler(ec, event());
return;
}
for (netlink::message_iterator mit(_buffer, rbytes); mit; ++mit) {
if (mit.type() == netlink::message::error) {
int error = mit.error();
if (error) {
boost::system::error_code err(error, boost::system::system_category());
_event_handler(err, event());
}
} else if (mit.type() == _family) {
genetlink::message msg(mit.get());
if (msg)
message_handler(msg);
else
std::cerr << "warning: invalid nl80211 message"
"{\n"
" method : opmip::linux::nl80211::event_handler()\n"
" nltype : " << uint(msg.type()) <<
"}\n";
} else {
std::cerr << "warning: unexpected netlink message type\n"
"{\n"
" method : opmip::linux::nl80211::event_handler()\n"
" nltype : " << uint(mit.type()) <<
"}\n";
}
}
_gnl.async_receive(boost::asio::buffer(_buffer), boost::bind(&nl80211::receive_handler, this, _1, _2));
}
bool XSqlQuery::next()
{
if (QSqlQuery::next())
{
if (_data)
{
if (_data->_keepTotals)
{
// increment all our values
QMapIterator<QString,double> mit(_data->_fieldTotals);
while(mit.hasNext())
{
mit.next();
_data->_fieldTotals[mit.key()] += value(mit.key()).toDouble();
_data->_fieldSubTotals[mit.key()] += value(mit.key()).toDouble();
}
}
_data->_currRecord = record();
}
return true;
}
return false;
}
void MALContext::deleteBuffer(unsigned int * bufferId)
{
M_PROFILE_SCOPE(MALContext::deleteBuffer);
if(*bufferId > 0)
{
// unlink sources
map<unsigned int, unsigned int>::iterator
mit (m_sources.begin()),
mend(m_sources.end());
for(;mit!=mend;++mit)
{
if(mit->second == (*bufferId))
{
stopSource(mit->first);
setSourceBufferId(mit->first, 0);
}
}
// delete buffer
alDeleteBuffers(1, bufferId);
}
}
void GraphEditor::setColorMap( QMap<QString, QColor> * cmap)
{
_colorMap = cmap;
if(_colorMap) {
QString col = _cbColors->currentText();
_cbColors->clear();
QMapIterator<QString,QColor> mit(*_colorMap);
while(mit.hasNext())
{
mit.next();
_cbColors->addItem(mit.key());
}
for( int i = 0; i < _cbColors->count(); i++) {
if(_cbColors->itemText(i) == col) {
_cbColors->setCurrentIndex(i);
break;
}
}
if(col.length() < 1) {
_cbColors_activated(_cbColors->currentText());
}
}
}
void nl80211::setup_family(boost::system::error_code& ec)
{
genetlink::message msg;
msg.flags(netlink::message::request | netlink::message::ack);
msg.command(genetlink::message::cmd_get_family);
msg.version(1);
msg.push_attr(genetlink::message::attr_family_name, "nl80211", 8);
_gnl.send(msg.cbuffer());
size_t rbytes = _gnl.receive(boost::asio::buffer(_buffer));
for (netlink::message_iterator mit(_buffer, rbytes); mit; ++mit) {
if (mit.type() == netlink::message::error) {
ec = boost::system::error_code(mit.error(), boost::system::system_category());
return;
}
if (mit.type() == netlink::message::min_type) {
genetlink::message rmsg(mit.get());
for (netlink::attribute_iterator ai(rmsg); ai; ++ai) {
switch (ai.type()) {
case genetlink::message::attr_family_id:
_family = *ai.get<uint16>();
break;
case genetlink::message::attr_family_name:
BOOST_ASSERT(!strcmp(ai.get<const char>(), "nl80211"));
break;
case genetlink::message::attr_version:
_version = *ai.get<uint32>();
break;
case genetlink::message::attr_hdrsize:
_hdrsize = *ai.get<uint32>();
break;
case genetlink::message::attr_mcast_groups:
for (netlink::attribute_iterator ali(rmsg, ai); ali; ++ali) {
const char* name = nullptr;
uint32 id = 0;
for (netlink::attribute_iterator aei(rmsg, ali); aei; ++aei) {
switch (aei.type()) {
case genetlink::message::attr_mcast_name:
name = aei.get<const char>();
break;
case genetlink::message::attr_mcast_id:
id = *aei.get<uint32>();
break;
}
}
if (name && !strcmp(name, "mlme")) {
_mlne_mcast_id = id;
break;
}
}
break;
}
}
break;
}
}
}
void QmitkDenoisingView::StartDenoising()
{
if (!m_ThreadIsRunning)
{
if (m_ImageNode.IsNotNull())
{
m_LastProgressCount = 0;
switch (m_SelectedFilter)
{
case NOFILTERSELECTED:
{
break;
}
case NLM:
{
// initialize NLM
m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
m_NonLocalMeansFilter = NonLocalMeansDenoisingFilterType::New();
if (m_BrainMaskNode.IsNotNull())
{
// use brainmask if set
m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
itk::Image<DiffusionPixelType, 3>::Pointer itkMask;
mitk::CastToItkImage(m_ImageMask, itkMask);
m_NonLocalMeansFilter->SetInputMask(itkMask);
itk::ImageRegionIterator< itk::Image<DiffusionPixelType, 3> > mit(itkMask, itkMask->GetLargestPossibleRegion());
mit.GoToBegin();
itk::Image<DiffusionPixelType, 3>::IndexType minIndex;
itk::Image<DiffusionPixelType, 3>::IndexType maxIndex;
minIndex.Fill(10000);
maxIndex.Fill(0);
while (!mit.IsAtEnd())
{
if (mit.Get())
{
// calculation of the start & end index of the smallest masked region
minIndex[0] = minIndex[0] < mit.GetIndex()[0] ? minIndex[0] : mit.GetIndex()[0];
minIndex[1] = minIndex[1] < mit.GetIndex()[1] ? minIndex[1] : mit.GetIndex()[1];
minIndex[2] = minIndex[2] < mit.GetIndex()[2] ? minIndex[2] : mit.GetIndex()[2];
maxIndex[0] = maxIndex[0] > mit.GetIndex()[0] ? maxIndex[0] : mit.GetIndex()[0];
maxIndex[1] = maxIndex[1] > mit.GetIndex()[1] ? maxIndex[1] : mit.GetIndex()[1];
maxIndex[2] = maxIndex[2] > mit.GetIndex()[2] ? maxIndex[2] : mit.GetIndex()[2];
}
++mit;
}
itk::Image<DiffusionPixelType, 3>::SizeType size;
size[0] = maxIndex[0] - minIndex[0] + 1;
size[1] = maxIndex[1] - minIndex[1] + 1;
size[2] = maxIndex[2] - minIndex[2] + 1;
m_MaxProgressCount = size[0] * size[1] * size[2];
}
else
{
// initialize the progressbar
m_MaxProgressCount = m_InputImage->GetDimension(0) * m_InputImage->GetDimension(1) * m_InputImage->GetDimension(2);
}
mitk::ProgressBar::GetInstance()->AddStepsToDo(m_MaxProgressCount);
m_NonLocalMeansFilter->SetInputImage(m_InputImage->GetVectorImage());
m_NonLocalMeansFilter->SetUseRicianAdaption(m_Controls->m_RicianCheckbox->isChecked());
m_NonLocalMeansFilter->SetUseJointInformation(m_Controls->m_JointInformationCheckbox->isChecked());
m_NonLocalMeansFilter->SetSearchRadius(m_Controls->m_SpinBoxParameter1->value());
m_NonLocalMeansFilter->SetComparisonRadius(m_Controls->m_SpinBoxParameter2->value());
m_NonLocalMeansFilter->SetVariance(m_Controls->m_DoubleSpinBoxParameter3->value());
// start denoising in detached thread
m_DenoisingThread.start(QThread::HighestPriority);
break;
}
case GAUSS:
{
// initialize GAUSS and run
m_InputImage = dynamic_cast<DiffusionImageType*> (m_ImageNode->GetData());
ExtractFilterType::Pointer extractor = ExtractFilterType::New();
extractor->SetInput(m_InputImage->GetVectorImage());
ComposeFilterType::Pointer composer = ComposeFilterType::New();
for (unsigned int i = 0; i < m_InputImage->GetVectorImage()->GetVectorLength(); ++i)
{
extractor->SetIndex(i);
extractor->Update();
m_GaussianFilter = GaussianFilterType::New();
m_GaussianFilter->SetVariance(m_Controls->m_SpinBoxParameter1->value());
if (m_BrainMaskNode.IsNotNull())
{
m_ImageMask = dynamic_cast<mitk::Image*>(m_BrainMaskNode->GetData());
itk::Image<DiffusionPixelType, 3>::Pointer itkMask = itk::Image<DiffusionPixelType, 3>::New();
mitk::CastToItkImage(m_ImageMask, itkMask);
itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::Pointer maskImageFilter = itk::MaskImageFilter<itk::Image<DiffusionPixelType, 3> , itk::Image<DiffusionPixelType, 3> >::New();
maskImageFilter->SetInput(extractor->GetOutput());
maskImageFilter->SetMaskImage(itkMask);
maskImageFilter->Update();
m_GaussianFilter->SetInput(maskImageFilter->GetOutput());
}
else
{
m_GaussianFilter->SetInput(extractor->GetOutput());
}
m_GaussianFilter->Update();
composer->SetInput(i, m_GaussianFilter->GetOutput());
}
composer->Update();
DiffusionImageType::Pointer image = DiffusionImageType::New();
image->SetVectorImage(composer->GetOutput());
image->SetReferenceBValue(m_InputImage->GetReferenceBValue());
image->SetDirections(m_InputImage->GetDirections());
image->InitializeFromVectorImage();
mitk::DataNode::Pointer imageNode = mitk::DataNode::New();
imageNode->SetData( image );
QString name = m_ImageNode->GetName().c_str();
imageNode->SetName((name+"_gauss_"+QString::number(m_Controls->m_SpinBoxParameter1->value())).toStdString().c_str());
GetDefaultDataStorage()->Add(imageNode);
break;
}
}
}
}
else
{
m_NonLocalMeansFilter->AbortGenerateDataOn();
m_CompletedCalculation = false;
}
}
void MLBSTrackingFilter< NumImageFeatures >::ThreadedGenerateData(const InputImageRegionType ®ionForThread, ThreadIdType threadId)
{
m_Mutex.Lock();
m_Threads++;
m_Mutex.Unlock();
typedef ImageRegionConstIterator< ItkUcharImgType > MaskIteratorType;
MaskIteratorType sit(m_SeedImage, regionForThread );
MaskIteratorType mit(m_MaskImage, regionForThread );
sit.GoToBegin();
mit.GoToBegin();
itk::Point<double> worldPos;
while( !sit.IsAtEnd() )
{
if (sit.Value()==0 || mit.Value()==0)
{
++sit;
++mit;
continue;
}
for (int s=0; s<m_SeedsPerVoxel; s++)
{
FiberType fib;
double tractLength = 0;
typename FeatureImageType::IndexType index = sit.GetIndex();
itk::ContinuousIndex<double, 3> start;
unsigned int counter = 0;
if (m_SeedsPerVoxel>1)
{
start[0] = index[0]+GetRandDouble(-0.5, 0.5);
start[1] = index[1]+GetRandDouble(-0.5, 0.5);
start[2] = index[2]+GetRandDouble(-0.5, 0.5);
}
else
{
start[0] = index[0];
start[1] = index[1];
start[2] = index[2];
}
// get staring position
m_SeedImage->TransformContinuousIndexToPhysicalPoint( start, worldPos );
// get starting direction
int candidates = 0;
double prob = 0;
vnl_vector_fixed<double,3> dirOld; dirOld.fill(0.0);
vnl_vector_fixed<double,3> dir = Classify(worldPos, candidates, dirOld, 0, prob);
if (dir.magnitude()<0.0001)
continue;
// forward tracking
tractLength = FollowStreamline(threadId, worldPos, dir, &fib, 0, false);
fib.push_front(worldPos);
if (m_RemoveWmEndFibers)
{
itk::Point<double> check = fib.back();
dirOld.fill(0.0);
vnl_vector_fixed<double,3> check2 = GetNewDirection(check, dirOld);
if (check2.magnitude()>0.001)
{
MITK_INFO << "Detected WM ending. Discarding fiber.";
continue;
}
}
// backward tracking
tractLength = FollowStreamline(threadId, worldPos, -dir, &fib, tractLength, true);
counter = fib.size();
if (m_RemoveWmEndFibers)
{
itk::Point<double> check = fib.front();
dirOld.fill(0.0);
vnl_vector_fixed<double,3> check2 = GetNewDirection(check, dirOld);
if (check2.magnitude()>0.001)
{
MITK_INFO << "Detected WM ending. Discarding fiber.";
continue;
}
}
if (tractLength<m_MinTractLength || counter<2)
continue;
m_Mutex.Lock();
m_Tractogram.push_back(fib);
m_Mutex.Unlock();
if (m_AbortTracking)
break;
}
if (m_AbortTracking)
break;
++sit;
++mit;
}
m_Threads--;
std::cout << "Thread " << threadId << " finished tracking" << std::endl;
}
void mitk::CLUtil::itkInterpolateCheckerboardPrediction(TImageType * checkerboard_prediction, Image::Pointer &checkerboard_mask, mitk::Image::Pointer & outimage)
{
typename TImageType::Pointer itk_checkerboard_mask;
mitk::CastToItkImage(checkerboard_mask,itk_checkerboard_mask);
typename TImageType::Pointer itk_outimage = TImageType::New();
itk_outimage->SetRegions(checkerboard_prediction->GetLargestPossibleRegion());
itk_outimage->SetDirection(checkerboard_prediction->GetDirection());
itk_outimage->SetOrigin(checkerboard_prediction->GetOrigin());
itk_outimage->SetSpacing(checkerboard_prediction->GetSpacing());
itk_outimage->Allocate();
itk_outimage->FillBuffer(0);
//typedef typename itk::ShapedNeighborhoodIterator<TImageType>::SizeType SizeType;
typedef itk::Size<3> SizeType;
SizeType size;
size.Fill(1);
itk::ShapedNeighborhoodIterator<TImageType> iit(size,checkerboard_prediction,checkerboard_prediction->GetLargestPossibleRegion());
itk::ShapedNeighborhoodIterator<TImageType> mit(size,itk_checkerboard_mask,itk_checkerboard_mask->GetLargestPossibleRegion());
itk::ImageRegionIterator<TImageType> oit(itk_outimage,itk_outimage->GetLargestPossibleRegion());
typedef typename itk::ShapedNeighborhoodIterator<TImageType>::OffsetType OffsetType;
OffsetType offset;
offset.Fill(0);
offset[0] = 1; // {1,0,0}
iit.ActivateOffset(offset);
mit.ActivateOffset(offset);
offset[0] = -1; // {-1,0,0}
iit.ActivateOffset(offset);
mit.ActivateOffset(offset);
offset[0] = 0; offset[1] = 1; //{0,1,0}
iit.ActivateOffset(offset);
mit.ActivateOffset(offset);
offset[1] = -1; //{0,-1,0}
iit.ActivateOffset(offset);
mit.ActivateOffset(offset);
// iit.ActivateOffset({{0,0,1}});
// iit.ActivateOffset({{0,0,-1}});
// mit.ActivateOffset({{0,0,1}});
// mit.ActivateOffset({{0,0,-1}});
while(!iit.IsAtEnd())
{
if(mit.GetCenterPixel() == 0)
{
typename TImageType::PixelType mean = 0;
for (auto i = iit.Begin(); ! i.IsAtEnd(); i++)
{ mean += i.Get(); }
//std::sort(list.begin(),list.end(),[](const typename TImageType::PixelType x,const typename TImageType::PixelType y){return x<=y;});
oit.Set((mean+0.5)/6.0);
}
else
{
oit.Set(iit.GetCenterPixel());
}
++iit;
++mit;
++oit;
}
mitk::CastToMitkImage(itk_outimage,outimage);
}
bool Coord_cl::lineOfSight( const Coord_cl &target, UI16 targetheight, bool touch )
{
//Console::instance()->send( QString( "LOScheck: Source:%1,Target:%2,Targetheight:%3\n" ).arg( z ).arg( target.z ).arg( targetheight ) );
if( target.map != map )
return false;
if( (x == target.x) && (y == target.y) && (z == target.z) )
return true; // if source and target are on the same position
SI32 n = ( target.x - x ), m = ( target.y - y ), i = 0;
SI08 sgn_x = ( x <= target.x ) ? 1 : (-1); // signum for x
SI08 sgn_y = ( y <= target.y ) ? 1 : (-1); // signum for y
SI08 sgn_z = ( z <= target.z ) ? 1 : (-1); // signum for z
if( x == target.x )
sgn_x = 0;
if( y == target.y )
sgn_y = 0;
if( z == target.z )
sgn_z = 0;
QValueList< Coord_cl > collisions;
//first we get our x-y-coordinates
if( sgn_x == 0 && sgn_y == 0 && !sgn_z == 0 ) // should fix shooting through floor issues
{
collisions.push_back( Coord_cl( x, y, 0, map ) );
}
else if( sgn_x == 0 ) // if we are on the same x-level, just push every x/y coordinate in y-direction from src to trg into the array
for( i = 0; i <= (sgn_y * m); ++i )
{
collisions.push_back( Coord_cl( x, y + (sgn_y * i), 0, map ) );
}
else if ( sgn_y == 0 ) // if we are on the same y-level, just push every x/y coordinate in x-direction from src to trg into the array
for( i = 0; i <= (sgn_x * n); ++i )
{
collisions.push_back( Coord_cl( x + (sgn_x * i), y, 0, map ) );
}
else
{
SI32 oldpos = y;
bool exaktpos = false;
for( i = 0; (sgn_x * n >= sgn_y * m) && (i <= (sgn_x * n)); i++ )
{
//Console::instance()->send( QString( "x:%1\n" ).arg( i ) );
SI32 gridx = x + (sgn_x * i);
if( ( ( n == 0 ) && ( gridx == 0 ) ) ||
( ( n + ( gridx * m ) == 0 ) ) )
continue;
else
{
if( exaktpos )
{
collisions.push_back( Coord_cl( gridx, oldpos-sgn_y, 0, map ) );
//Console::instance()->send( QString( "add exaktpos coordinate %1,%2\n" ).arg( gridx ).arg( oldpos-sgn_y ) );
exaktpos = false;
}
// linear evaluation of extended 2x2 matrix, abbreviated
double t = (double)sgn_x * ((double)i+0.5) * (double)m / (double)n + (double)y;
//Console::instance()->send( QString( "t:%1\n" ).arg( t ) );
if( ((sgn_y>0) && (specialFloor(t)==oldpos+0.5)) || ((sgn_y<0) && (specialFloor(t)==oldpos-0.5)) )
{
exaktpos = true;
}
if( ((sgn_y>0) && (t<oldpos+0.5)) || ((sgn_y<0) && (t>oldpos-0.5)) || (oldpos==target.y) )
{
collisions.push_back( Coord_cl( gridx, oldpos, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( gridx ).arg( oldpos ) );
}
// but if not, we have to take BOTH coordinates, which the calculated collision is between!
else
{
collisions.push_back( Coord_cl( gridx, oldpos, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( gridx ).arg( oldpos ) );
oldpos += sgn_y;
collisions.push_back( Coord_cl( gridx, oldpos, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( gridx ).arg( oldpos ) );
}
}
}
oldpos = x;
exaktpos = false;
for( i = 0; (sgn_y * m >= sgn_x * n) && (i <= (sgn_y * m)); ++i )
{
//Console::instance()->send( QString( "y:%1\n" ).arg( i ) );
SI32 gridy = y + (sgn_y * i);
if( ( ( m == 0 ) && ( gridy == 0 ) ) ||
( ( m + ( gridy * n ) == 0 ) ) )
continue;
else
{
if( exaktpos )
{
collisions.push_back( Coord_cl( oldpos-sgn_x, gridy, 0, map ) );
//Console::instance()->send( QString( "add exaktpos coordinate %1,%2\n" ).arg( oldpos-sgn_x ).arg( gridy ) );
exaktpos = false;
}
double t = (double)x + (double)n / (double)m * (double)sgn_y * ((double)i+0.5);
//Console::instance()->send( QString( "t:%1\n" ).arg( t ) );
if( ((sgn_x>0) && (specialFloor(t)==oldpos+0.5)) || ((sgn_x<0) && (specialFloor(t)==oldpos-0.5)) )
{
exaktpos = true;
}
if( ((sgn_x>0) && (t<oldpos+0.5)) || ((sgn_x<0) && (t>oldpos-0.5)) || (oldpos==target.x) )
{
collisions.push_back( Coord_cl( oldpos, gridy, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( oldpos ).arg( gridy ) );
}
// but if not, we have to take BOTH coordinates, which the calculated collision is between!
else
{
collisions.push_back( Coord_cl( oldpos, gridy, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( oldpos ).arg( gridy ) );
oldpos += sgn_x;;
collisions.push_back( Coord_cl( oldpos, gridy, 0, map ) );
//Console::instance()->send( QString( "add coordinate %1,%2\n" ).arg( oldpos ).arg( gridy ) );
}
}
}
}
// the next will search for multis
QPtrList< cItem > multis;
RegionIterator4Items ri( *this );
for( ri.Begin(); !ri.atEnd(); ri++ )
{
P_ITEM pi = ri.GetData();
if( pi && pi->id() >= 0x4000 )
{
multis.append( pi );
}
}
//touch wird von notouch getrennt, da der notouch algorithmus wesentlich aufwändiger
//ist (touch benötigt die erste for-schleife nicht), macht den code zwar bisserl
//unübersichtlicher, aber ist wesentlich effizienter
//touch is separated from notouch, because the notouch calculation is much more to do
//( one additional for-loop )
if( targetheight > 0 )
{
--targetheight;
}
if( !touch )
{
for( i = target.z+targetheight; i >= target.z; --i )
{
bool blocked = false;
//Console::instance()->send( QString( "i:%1\n" ).arg( i ) );
double dz;
double gradient;
double offset;
if( (sgn_x == 0) && (sgn_y == 0) )
{
dz = (double)i - (double)z;
gradient = 1; //only to avoid problems, isnt used
offset = 1;
}
else
{
dz = ( (double)i -(double)z ) / sqrt( ((double)target.x - (double)x)*((double)target.x - (double)x) + ((double)target.y - (double)y)*((double)target.y - (double)y) );
gradient = (double)m / (double)n;
offset = 0.5*( (double)y + (double)target.y - gradient*( x + target.x ) );
}
map_st map1, map2;
SI32 j;
bool posHigherThanMap;
map1 = Map->seekMap( (*this) );
if( map1.z > z )
{
posHigherThanMap = false;
}
else
{
posHigherThanMap = true;
}
//Console::instance()->send( QString( "after first things\n" ) );
QValueList< Coord_cl >::iterator pit = collisions.begin();
while( pit != collisions.end() )
{
//Console::instance()->send( QString( "coordinate:%1,%2 dz:%3\n" ).arg( (*pit).x ).arg( (*pit).y ).arg( dz ) );
//lets see what z-coordinates we have to test
//we do our calculations exakt, because its the only way to solve all problems
//of floor
//"minimum" ist am anfang der platte, "maximum" am ende
//our line is y = gradient * x + offset
//or x = ( y - offset ) / gradient
//we now have to test, where the line cuts one position
//start and endposition has to be done alone
double z1 = -300;
double z2 = -300;
SI08 zmin, zmax;
if( (sgn_x == 0) && (sgn_y == 0) )
{
if( dz > 0 )
{
zmin = z+1;
zmax = i;
}
else
{
zmin = i+1;
zmax = z;
}
}
else if( sgn_x == 0 )
{
//gradient only in y-direction
z1 = (double)i - dz*( fabs( (double)target.y - (double)((*pit).y) ) -0.5 );
z2 = (double)i - dz*( fabs( (double)target.y - (double)((*pit).y) ) +0.5 );
//Console::instance()->send( QString( "i:%1,ty:%2,cy:%3\n" ).arg( i ).arg( target.y ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
if( z1 > z2 )
{
zmin = (SI08)floor( z2 );
zmax = (SI08)ceilf( z1 );
}
else
{
zmin = (SI08)floor( z1 );
zmax = (SI08)ceilf( z2 );
}
/*another try, but i think its needed for all positions, not only start and end...
//target
if( (*pit).y == target.y )
{
if( dz > 0 )
{
zmax = QMIN( zmax, i );
//Console::instance()->send( QString( "TargetY, zmax:%1, i:%2\n" ).arg( zmax ).arg( i ) );
}
else
{
zmin = QMAX( zmin, i+1 );
//Console::instance()->send( QString( "TargetY, zmin:%1, i:%2\n" ).arg( zmin ).arg( i ) );
}
}
//source
if( (*pit).y == y )
{
if( dz > 0 )
{
zmin = QMAX( zmin, z );
//Console::instance()->send( QString( "SourceY, zmin:%1, i:%2\n" ).arg( zmax ).arg( i ) );
}
else
{
zmax = QMIN( zmax, z );
//Console::instance()->send( QString( "SourceY, zmax:%1, i:%2\n" ).arg( zmax ).arg( i ) );
}
}*/
if( dz > 0 )
{
zmax = QMIN( zmax, i );
zmin = QMAX( zmin, z );
}
else
{
zmin = QMAX( zmin, i+1 );
zmax = QMIN( zmax, z );
}
}
else if( sgn_y == 0 )
{
//gradient only in y-direction
z1 = (double)i - dz*( fabs( (double)target.x - (double)((*pit).x) ) -0.5 );
z2 = (double)i - dz*( fabs( (double)target.x - (double)((*pit).x) ) +0.5 );
//Console::instance()->send( QString( "i:%1,tx:%2,cx:%3\n" ).arg( i ).arg( target.x ).arg( (*pit).x ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
if( z1 > z2 )
{
zmin = (SI08)floor( z2 );
zmax = (SI08)ceilf( z1 );
}
else
{
zmin = (SI08)floor( z1 );
zmax = (SI08)ceilf( z2 );
}
if( dz > 0 )
{
zmax = QMIN( zmax, i );
zmin = QMAX( zmin, z );
}
else
{
zmin = QMAX( zmin, i+1 );
zmax = QMIN( zmax, z );
}
}
else
{
//4 lines to test
double gradx = ( (double)target.y*(double)z - (double)y*(double)i ) / ( (double)target.y*(double)x - (double)y*(double)target.x );
double grady = ( (double)target.x*(double)z - (double)x*(double)i ) / ( (double)y*(double)target.x - (double)target.y*(double)x );
//Console::instance()->send( QString( "gradx:%1,grady:%2\n" ).arg( gradx ).arg( grady ) );
//Console::instance()->send( QString( "Gradient:%1,Offset:%2\n" ).arg( gradient ).arg( offset ) );
double temp;
temp = specialFloor( gradient*( (double)((*pit).x) - 0.5 ) + offset );
//Console::instance()->send( QString( "temp1:%1\n" ).arg( temp ) );
if( ( temp >= ((double)((*pit).y)-0.5) ) && ( temp <= ((double)((*pit).y)+0.5) ) )
{
if( z1 > -300 )
{
z2 = gradx * ( (double)((*pit).x)-0.5 ) + grady * temp;
}
else
{
z1 = gradx * ( (double)((*pit).x)-0.5 ) + grady * temp;
}
//Console::instance()->send( QString( "1:i:%1,tx:%2,ty:%3,cy:%4,cy:%5\n" ).arg( i ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
}
temp = specialFloor( gradient*( (double)((*pit).x) + 0.5 ) + offset );
//Console::instance()->send( QString( "temp2:%1\n" ).arg( temp ) );
if( ( temp >= ((double)((*pit).y)-0.5) ) && ( temp <= ((double)((*pit).y)+0.5) ) )
{
if( z1 > -300 )
{
z2 = gradx * ( (double)((*pit).x)+0.5 ) + grady * temp;
}
else
{
z1 = gradx * ( (double)((*pit).x)+0.5 ) + grady * temp;
}
//Console::instance()->send( QString( "2:i:%1,tx:%2,ty:%3,cy:%4,cy:%5\n" ).arg( i ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
}
temp = specialFloor( (double)((*pit).y) - 0.5 - offset ) / gradient;
//Console::instance()->send( QString( "temp3:%1\n" ).arg( temp ) );
if( ( temp > ((double)((*pit).x)-0.5) ) && ( temp < ((double)((*pit).x)+0.5) ) )
{
if( z1 > -300 )
{
z2 = gradx * temp + grady * ((double)((*pit).y)-0.5);
}
else
{
z1 = gradx * temp + grady * ((double)((*pit).y)-0.5);
}
//Console::instance()->send( QString( "3:i:%1,tx:%2,ty:%3,cy:%4,cy:%5\n" ).arg( i ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
}
temp = specialFloor( (double)((*pit).y) + 0.5 - offset ) / gradient;
//Console::instance()->send( QString( "temp4:%1\n" ).arg( temp ) );
if( ( temp > ((double)((*pit).x)-0.5) ) && ( temp < ((double)((*pit).x)+0.5) ) )
{
if( z1 > -300 )
{
z2 = gradx * temp + grady * ((double)((*pit).y)+0.5);
}
else
{
z1 = gradx * temp + grady * ((double)((*pit).y)+0.5);
}
//Console::instance()->send( QString( "4:i:%1,tx:%2,ty:%3,cy:%4,cy:%5\n" ).arg( i ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
}
//Console::instance()->send( QString( "z1:%1,z2:%2\n" ).arg( z1 ).arg( z2 ) );
if( z1 > z2 )
{
zmin = (SI08)floor( z2 );
zmax = (SI08)ceilf( z1 );
}
else
{
zmin = (SI08)floor( z1 );
zmax = (SI08)ceilf( z2 );
}
if( z2 == -300 )
{
zmin = (SI08)floor( z1 );
}
if( dz > 0 )
{
zmax = QMIN( zmax, i );
zmin = QMAX( zmin, z );
}
else
{
zmin = QMAX( zmin, i+1 );
zmax = QMIN( zmax, z );
}
//Console::instance()->send( QString( "zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
}
/*SI08 zmin = (SI08)floor( i - dz*sqrt( ((double)target.x - (double)(*pit).x)*((double)target.x - (double)(*pit).x) + ((double)target.y - (double)(*pit).y)*((double)target.y - (double)(*pit).y) ) );
SI08 zmax;
//Console::instance()->send( QString( "zmin:%1,dz:%2\n" ).arg( zmin ).arg( dz ) );
if( dz > 0 )
{
zmin = QMAX( (SI08)floor( zmin - dz/2 ), z+1 );
zmax = QMIN( zmin + dz + 1, target.z+targetheight+1 ); //to prevent floor-mistakes
}
else
{
zmin = QMIN( (SI08)floor( zmin + dz/2 ), target.z+1 );
zmax = QMAX( zmin - dz + 1, z ); //to prevent floor-mistakes
}*/
// Texture mapping
map1 = Map->seekMap( *pit );
map2 = Map->seekMap( Coord_cl( (*pit).x + sgn_x, (*pit).y + sgn_y, (*pit).z, map ) );
//Console::instance()->send( QString( "maphoehe:%1\n" ).arg( map1.z ) );
StaticsIterator msi = Map->staticsIterator( *pit );
if( (map1.id != 2) && (map2.id != 2) )
{
if( ( map1.z >= zmin ) && ( map1.z <= zmax ) )
{
//its just in our way
//Console::instance()->send( QString( "Map gescheitert\n" ) );
blocked = true;
break;
}
//now we have to test, if this tile is under our line and the next above or
//vice verse
//in this case, both dont cut our line, but the mapconnection between them
//should do
if( ( ( map1.z < map2.z ) && ( map1.z < zmin ) && ( map2.z > zmax+dz ) ) || // 1) lineofsight collides with a map "wall"
( ( map1.z > map2.z ) && ( map1.z > zmin ) && ( map2.z < zmax-dz ) ) ||
( ( ( map1.id >= 431 && map1.id <= 432 ) || // 3) lineofsight cuts a mountain
( map1.id >= 467 && map1.id <= 475 ) ||
( map1.id >= 543 && map1.id <= 560 ) ||
( map1.id >= 1754 && map1.id <= 1757 ) ||
( map1.id >= 1787 && map1.id <= 1789 ) ||
( map1.id >= 1821 && map1.id <= 1824 ) ||
( map1.id >= 1851 && map1.id <= 1854 ) ||
( map1.id >= 1881 && map1.id <= 1884 ) ) &&
( posHigherThanMap ) && ( msi.atEnd() ) ) ) // mountains cut only if we are not beneath them
{
//Console::instance()->send( QString( "map1:%1,map2:%2\n" ).arg( map1.z ).arg( map2.z ) );
blocked = true;
break;
}
}
//Console::instance()->send( QString( "after map\n" ) );
// Statics
tile_st tile;
while( !msi.atEnd() )
{
tile = TileCache::instance()->getTile( msi->itemid );
//if it is in our way
//Console::instance()->send( QString( "tilepos:%1,zmax:%2" ).arg( msi->zoff ).arg( zmax ) );
//Console::instance()->send( QString( "zmin:%3\n" ).arg( zmin ) );
if( ( zmax >= msi->zoff ) && ( zmin <= ( msi->zoff + tile.height ) ) )
{
//Console::instance()->send( QString( "statictile, id: %1\n" ).arg( msi->itemid ) );
if( tile.isNoShoot() )
{
blocked = true;
break;
}
}
++msi;
}
if( blocked )
{
break;
}
//Console::instance()->send( QString( "after statics\n" ) );
// Items
RegionIterator4Items rj( (*pit), 0 );
for( rj.Begin(); !rj.atEnd(); rj++ )
{
P_ITEM pi = rj.GetData();
if( pi && pi->id() < 0x4000 )
{
tile = TileCache::instance()->getTile( pi->id() );
if( ( zmax >= pi->pos().z ) && ( zmin <= ( pi->pos().z + tile.height ) ) && ( pi->visible() == 0 ) )
{
//Console::instance()->send( QString( "item, id: %1" ).arg( pi->id() ) );
if( tile.isNoShoot() )
{
blocked = true;
break;
}
}
}
}
if( blocked )
{
break;
}
//Console::instance()->send( QString( "after items\n" ) );
// Multis
QPtrListIterator< cItem > mit( multis );
P_ITEM pi;
while( ( pi = mit.current() ) )
{
MultiDefinition* def = MultiCache::instance()->getMulti( pi->id() - 0x4000 );
if ( !def )
continue;
QValueVector<multiItem_st> multi = def->getEntries();
for( j = 0; j < multi.size(); ++j )
{
if( ( multi[j].visible ) && ( pi->pos().x + multi[j].x == (*pit).x ) &&
( pi->pos().y + multi[j].y == (*pit).y ) )
{
tile = TileCache::instance()->getTile( multi[j].tile );
if( ( zmax >= pi->pos().z + multi[j].z ) &&
( zmin <= pi->pos().z + multi[j].z + tile.height ) )
{
if( tile.isNoShoot() )
{
blocked = true;
break;
}
}
}
}
++mit;
}
//Console::instance()->send( QString( "after multis\n" ) );
++pit;
}
if( !blocked )
return true;
}
//there was no line to see through
return false;
}
//now touch=true
else
{
//Console::instance()->send( "touch\n" );
double dz_up, dz_down;
double gradient;
double offset;
if( (sgn_x == 0) && (sgn_y == 0) )
{
dz_up = ( (double)targetheight + (double)target.z ) - (double)z;
dz_down = (double)target.z - ( (double)z - (double)15 );
gradient = 1; //only to prevent problems, isnt used
offset = 1;
}
else
{
//Console::instance()->send( QString( "xdiff:%1,ydiff:%2\n" ).arg( (double)target.x - (double)x ).arg( (double)target.y - (double)y ) );
dz_up = ( ( (double)targetheight + (double)target.z ) - (double)z ) / sqrt( ((double)target.x - (double)x)*((double)target.x - (double)x) + ((double)target.y - (double)y)*((double)target.y - (double)y) );
dz_down = ( (double)target.z - ( (double)z - (double)15 ) ) / sqrt( ((double)target.x - (double)x)*((double)target.x - (double)x) + ((double)target.y - (double)y)*((double)target.y - (double)y) );
gradient = (double)m / (double)n;
offset = 0.5*( (double)y + (double)target.y - gradient*( x + target.x ) );
}
map_st map1, map2;
SI32 j;
bool posHigherThanMap;
map1 = Map->seekMap( (*this) );
if( map1.z > z )
{
posHigherThanMap = false;
}
else
{
posHigherThanMap = true;
}
//Console::instance()->send( QString( "after first things\n" ) );
QValueList< Coord_cl >::iterator pit = collisions.begin();
while( pit != collisions.end() )
{
//Console::instance()->send( QString( "coordinate:%1,%2\n" ).arg( (*pit).x ).arg( (*pit).y ) );
//lets see what z-coordinates we have to test
//anmerkung: touch kommt nur für chars vor, grösse von chars ist 15
//SI08 zmin = (SI08)floor( (double)z - (double)sourceheight + dz_down*sqrt( ((double)target.x - (double)(*pit).x)*((double)target.x - (double)(*pit).x) + ((double)target.y - (double)(*pit).y)*((double)target.y - (double)(*pit).y) ) );
//SI08 zmax = (SI08)floor( (double)z + dz_up*sqrt( ((double)target.x - (double)(*pit).x)*((double)target.x - (double)(*pit).x) + ((double)target.y - (double)(*pit).y)*((double)target.y - (double)(*pit).y) ) );
SI08 zmin, zmax;
double z1_up = -300;
double z2_up = -300;
double z1_down = -300;
double z2_down = -300;
bool targetpos = false;
//Console::instance()->send( QString( "dz_down:%3,dz_up:%4\n" ).arg( dz_down ).arg( dz_up ) );
if( (sgn_x == 0) && (sgn_y == 0) )
{
if( dz_up > 0 )
{
zmin = z+1;
zmax = target.z;
}
else
{
zmin = target.z+1;
zmax = z;
}
targetpos = true;
if( (dz_up >= 0) && (dz_down >= 0) )
{
if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
//we ignore this coordinate
++pit;
continue;
}
}
else if( (dz_up <= 0) && (dz_down <= 0) )
{
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else
{
++pit;
continue;
}
}
else
{
//we may have to split the test into two if we would do it exactly
//but i think we can throw away the test from down in this case
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
++pit;
continue;
}
}
}
else if( sgn_x == 0 )
{
z1_up = target.z + targetheight - dz_up*( fabs( (double)target.y - (double)((*pit).y) ) -0.5 );
z2_up = target.z + targetheight - dz_up*( fabs( (double)target.y - (double)((*pit).y) ) +0.5 );
z1_down = target.z - dz_down*( fabs( (double)target.y - (double)((*pit).y) ) -0.5 );
z2_down = target.z - dz_down*( fabs( (double)target.y - (double)((*pit).y) ) +0.5 );
//Console::instance()->send( QString( "ty:%2,cy:%3\n" ).arg( target.y ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1_up:%1,z2_up:%2,z1_down:%3,z2_down:%4\n" ).arg( z1_up ).arg( z2_up ).arg( z1_down ).arg( z2_down ) );
zmax = QMAX( ceil( z1_up ), ceil( z2_up ) );
zmin = QMIN( floor( z1_down ), floor( z2_down ) );
//Console::instance()->send( QString( "y:zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
if( dz_up > 0 )
{
zmax = QMIN( zmax, target.z+targetheight );
}
else
{
zmax = QMIN( zmax, z );
}
//Console::instance()->send( QString( "y2:zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
if( dz_down > 0 )
{
zmin = QMAX( zmin, z-14 );
}
else
{
zmin = QMAX( zmin, target.z+1 );
}
//Console::instance()->send( QString( "y3:zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
if( (*pit).y == target.y )
{
targetpos = true;
if( (dz_up >= 0) && (dz_down >= 0) )
{
if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
//we ignore this coordinate
++pit;
continue;
}
}
else if( (dz_up <= 0) && (dz_down <= 0) )
{
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else
{
++pit;
continue;
}
}
else
{
//we may have to split the test into two if we would do it exactly
//but i think we can throw away the test from down in this case
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
++pit;
continue;
}
}
//Console::instance()->send( QString( "y4:zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
}
}
else if( sgn_y == 0 )
{
z1_up = target.z + targetheight - dz_up*( fabs( (double)target.x - (double)((*pit).x) ) -0.5 );
z2_up = target.z + targetheight - dz_up*( fabs( (double)target.x - (double)((*pit).x) ) +0.5 );
z1_down = target.z - dz_down*( fabs( (double)target.x - (double)((*pit).x) ) -0.5 );
z2_down = target.z - dz_down*( fabs( (double)target.x - (double)((*pit).x) ) +0.5 );
//Console::instance()->send( QString( "tx:%2,cx:%3\n" ).arg( target.x ).arg( (*pit).x ) );
//Console::instance()->send( QString( "z1_up:%1,z2_up:%2,z1_down:%3,z2_down:%4\n" ).arg( z1_up ).arg( z2_up ).arg( z1_down ).arg( z2_down ) );
zmax = QMAX( ceil( z1_up ), ceil( z2_up ) );
zmin = QMIN( floor( z1_down ), floor( z2_down ) );
if( dz_up > 0 )
{
zmax = QMIN( zmax, target.z+targetheight );
}
else
{
zmax = QMIN( zmax, z );
}
if( dz_down > 0 )
{
zmin = QMAX( zmin, z-14 );
}
else
{
zmin = QMAX( zmin, target.z+1 );
}
if( (*pit).x == target.x )
{
targetpos = true;
if( (dz_up >= 0) && (dz_down >= 0) )
{
if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
//we ignore this coordinate
++pit;
continue;
}
}
else if( (dz_up <= 0) && (dz_down <= 0) )
{
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else
{
++pit;
continue;
}
}
else
{
//we may have to split the test into two if we would do it exactly
//but i think we can throw away the test from down in this case
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
++pit;
continue;
}
}
}
}
else
{
double gradx_up = ( (double)target.y*(double)z - (double)y*(double)(target.z + targetheight) ) / ( (double)target.y*(double)x - (double)y*(double)target.x );
double grady_up = ( (double)target.x*(double)z - (double)x*(double)(target.z + targetheight) ) / ( (double)y*(double)target.x - (double)target.y*(double)x );
double gradx_down = ( (double)target.y*(double)(z-15) - (double)y*(double)(target.z) ) / ( (double)target.y*(double)x - (double)y*(double)target.x );
double grady_down = ( (double)target.x*(double)(z-15) - (double)x*(double)(target.z) ) / ( (double)y*(double)target.x - (double)target.y*(double)x );
//Console::instance()->send( QString( "gradx_up:%1,grady_up:%2,gradx_down:%3,grady_down:%4\n" ).arg( gradx_up ).arg( grady_up ).arg( gradx_down ).arg( grady_down ) );
//Console::instance()->send( QString( "Gradient:%1,Offset:%2\n" ).arg( gradient ).arg( offset ) );
double temp = specialFloor( gradient*( (double)((*pit).x) - 0.5 ) + offset );
//Console::instance()->send( QString( "temp1:%1\n" ).arg( temp ) );
if( ( temp >= ((double)((*pit).y)-0.5) ) && ( temp <= ((double)((*pit).y)+0.5) ) )
{
if( z1_up > -300 )
{
z2_up = gradx_up * ( (double)((*pit).x)-0.5 ) + grady_up * temp;
z2_down = gradx_down * ( (double)((*pit).x)-0.5 ) + grady_down * temp;
}
else
{
z1_up = gradx_up * ( (double)((*pit).x)-0.5 ) + grady_up * temp;
z1_down = gradx_down * ( (double)((*pit).x)-0.5 ) + grady_down * temp;
}
//Console::instance()->send( QString( "tx:%1,ty:%2,cy:%3,cy:%4\n" ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1_up:%1,z1_down:%2,z2_up:%3,z2_down:%4\n" ).arg( z1_up ).arg( z1_down ).arg( z2_up ).arg( z2_down ) );
}
temp = specialFloor( gradient*( (double)((*pit).x) + 0.5 ) + offset );
//Console::instance()->send( QString( "temp2:%1\n" ).arg( temp ) );
if( ( temp >= ((double)((*pit).y)-0.5) ) && ( temp <= ((double)((*pit).y)+0.5) ) )
{
if( z1_up > -300 )
{
z2_up = gradx_up * ( (double)((*pit).x)+0.5 ) + grady_up * temp;
z2_down = gradx_down * ( (double)((*pit).x)+0.5 ) + grady_down * temp;
}
else
{
z1_up = gradx_up * ( (double)((*pit).x)+0.5 ) + grady_up * temp;
z1_down = gradx_down * ( (double)((*pit).x)+0.5 ) + grady_down * temp;
}
//Console::instance()->send( QString( "tx:%1,ty:%2,cy:%3,cy:%4\n" ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1_up:%1,z1_down:%2,z2_up:%3,z2_down:%4\n" ).arg( z1_up ).arg( z1_down ).arg( z2_up ).arg( z2_down ) );
}
temp = specialFloor( (double)((*pit).y) - 0.5 - offset ) / gradient;
//Console::instance()->send( QString( "temp3:%1\n" ).arg( temp ) );
if( ( temp > ((double)((*pit).x)-0.5) ) && ( temp < ((double)((*pit).x)+0.5) ) )
{
if( z1_up > -300 )
{
z2_up = gradx_up * temp + grady_up * ((double)((*pit).y)-0.5);
z2_down = gradx_down * temp + grady_down * ((double)((*pit).y)-0.5);
}
else
{
z1_up = gradx_up * temp + grady_up * ((double)((*pit).y)-0.5);
z1_down = gradx_down * temp + grady_down * ((double)((*pit).y)-0.5);
}
//Console::instance()->send( QString( "tx:%1,ty:%2,cy:%3,cy:%4\n" ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1_up:%1,z1_down:%2,z2_up:%3,z2_down:%4\n" ).arg( z1_up ).arg( z1_down ).arg( z2_up ).arg( z2_down ) );
}
temp = specialFloor( (double)((*pit).y) + 0.5 - offset ) / gradient;
//Console::instance()->send( QString( "temp4:%1\n" ).arg( temp ) );
if( ( temp > ((double)((*pit).x)-0.5) ) && ( temp < ((double)((*pit).x)+0.5) ) )
{
if( z1_up > -300 )
{
z2_up = gradx_up * temp + grady_up * ((double)((*pit).y)+0.5);
z2_down = gradx_down * temp + grady_down * ((double)((*pit).y)+0.5);
}
else
{
z1_up = gradx_up * temp + grady_up * ((double)((*pit).y)+0.5);
z1_down = gradx_down * temp + grady_down * ((double)((*pit).y)+0.5);
}
//Console::instance()->send( QString( "tx:%1,ty:%2,cy:%3,cy:%4\n" ).arg( target.x ).arg( target.y ).arg( (*pit).x ).arg( (*pit).y ) );
//Console::instance()->send( QString( "z1_up:%1,z1_down:%2,z2_up:%3,z2_down:%4\n" ).arg( z1_up ).arg( z1_down ).arg( z2_up ).arg( z2_down ) );
}
//Console::instance()->send( QString( "ergebnis: z1_up:%1,z1_down:%2,z2_up:%3,z2_down:%4\n" ).arg( z1_up ).arg( z1_down ).arg( z2_up ).arg( z2_down ) );
if( z2_up == -300 )
{
zmin = floor( z1_down );
zmax = ceil( z1_up );
}
else
{
zmin = QMIN( floor( z1_down ), floor( z2_down ) );
zmax = QMAX( ceil( z1_up ), ceil( z2_up ) );
}
//Console::instance()->send( QString( "zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
if( dz_up > 0 )
{
zmax = QMIN( zmax, target.z+targetheight );
}
else
{
zmax = QMIN( zmax, z );
}
if( dz_down > 0 )
{
zmin = QMAX( zmin, z-14 );
}
else
{
zmin = QMAX( zmin, target.z+1 );
}
//Console::instance()->send( QString( "zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
if( ((*pit).x == target.x) && ((*pit).y == target.y) )
{
targetpos = true;
if( (dz_up >= 0) && (dz_down >= 0) )
{
if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
//we ignore this coordinate
++pit;
continue;
}
}
else if( (dz_up <= 0) && (dz_down <= 0) )
{
if( zmax > target.z + targetheight+1)
{
zmin = target.z + targetheight + 2;
}
else
{
++pit;
continue;
}
}
else
{
//we may have to split the test into two if we would do it exactly
//but i think we can throw away the test from down in this case
if( zmax > target.z + targetheight+1 )
{
zmin = target.z + targetheight + 2;
}
else if( zmin < target.z )
{
zmax = target.z -1;
}
else
{
++pit;
continue;
}
}
}
}
//Console::instance()->send( QString( "zmin:%1,zmax:%2\n" ).arg( zmin ).arg( zmax ) );
// Texture mapping
map1 = Map->seekMap( *pit );
map2 = Map->seekMap( Coord_cl( (*pit).x + sgn_x, (*pit).y + sgn_y, (*pit).z, map ) );
//Console::instance()->send( QString( "try2" ) );
StaticsIterator msi = Map->staticsIterator( *pit );
RegionIterator4Items rj( (*pit), 0 );
if( (map1.id != 2) && (map2.id != 2) )
{
if( ( map1.z > zmin ) && ( map1.z < zmax ) )
{
//its just in our way
//Console::instance()->send( QString( "map cut 1\n" ) );
return false;
}
//now we have to test, if this tile is under our line and the next above or
//vice verse
//in this case, both dont cut our line, but the mapconnection between them
//should do
land_st tile = TileCache::instance()->getLand( map1.id );
if( ( ( map1.z < map2.z ) && ( map1.z < zmin ) && ( map2.z > zmax+dz_down ) && !targetpos ) || // 1) lineofsight collides with a map "wall"
( ( map1.z > map2.z ) && ( map1.z > zmin ) && ( map2.z < zmin+dz_down ) && !targetpos ) ||
( tile.isBlocking() && posHigherThanMap && msi.atEnd() && rj.atEnd() ) )
{
//Console::instance()->send( QString( "map1:%1,map2:%2,map1id:%3\n" ).arg( map1.z ).arg( map2.z ).arg( map1.id ) );
if( ( map1.z < map2.z ) && ( map1.z < zmin ) && ( map2.z > zmax+dz_down ) )
{
//Console::instance()->send( QString( "mapcut1\n" ) );
}
else if( ( map1.z > map2.z ) && ( map1.z > zmin ) && ( map2.z < zmin+dz_down ) )
{
//Console::instance()->send( QString( "mapcut2\n" ) );
}
else if( tile.isBlocking() && posHigherThanMap && msi.atEnd() && rj.atEnd() )
{
//Console::instance()->send( QString( "mapcut3\n" ) );
}
else
{
//Console::instance()->send( QString( "mapcut: this isnt possible\n" ) );
}
return false;
}
}
//Console::instance()->send( QString( "after map\n" ) );
// Statics
tile_st tile;
while( !msi.atEnd() )
{
tile = TileCache::instance()->getTile( msi->itemid );
//Console::instance()->send( QString( "statictilepos:%1,zmax:%2,zmin:%3\n" ).arg( msi->zoff ).arg( zmax ).arg( zmin ) );
//if it is in our way
if( ( zmax >= msi->zoff ) && ( zmin <= ( msi->zoff + tile.height ) ) )
{
if( tile.isBlocking() || tile.isRoofOrFloorTile() )
{
return false;
}
}
++msi;
}
//Console::instance()->send( QString( "after statics\n" ) );
// Items
//Console::instance()->send( QString( "Items at: %1,%2,%3,%4\n" ).arg( (*pit).x ).arg( (*pit).y ).arg( (*pit).z ).arg( (*pit).map ) );
for( rj.Begin(); !rj.atEnd(); rj++ )
{
//Console::instance()->send( QString( "foritem\n" ) );
P_ITEM pi = rj.GetData();
if( pi && pi->id() < 0x4000 )
{
tile = TileCache::instance()->getTile( pi->id() );
//Console::instance()->send( QString( "itemtilepos:%1,zmax:%2,zmin:%3\n" ).arg( pi->pos().z ).arg( zmax ).arg( zmin ) );
if( ( zmax >= pi->pos().z ) && ( zmin <= ( pi->pos().z + tile.height ) ) && ( pi->visible() == 0 ) )
{
if( tile.isBlocking() || tile.isRoofOrFloorTile() )
{
//Console::instance()->send( QString( "Item:%1,Z:%2,Height:%3\n" ).arg( pi->id() ).arg( pi->pos().z ).arg( tile.height ) );
return false;
}
}
}
}
//Console::instance()->send( QString( "after items\n" ) );
// Multis
QPtrListIterator< cItem > mit( multis );
P_ITEM pi;
while( ( pi = mit.current() ) )
{
MultiDefinition* def = MultiCache::instance()->getMulti( pi->id() - 0x4000 );
if ( !def )
{
++mit;
continue;
}
QValueVector<multiItem_st> multi = def->getEntries();
for( j = 0; j < multi.size(); ++j )
{
if( ( multi[j].visible ) && ( pi->pos().x + multi[j].x == (*pit).x ) &&
( pi->pos().y + multi[j].y == (*pit).y ) )
{
tile = TileCache::instance()->getTile( multi[j].tile );
if( ( zmax >= pi->pos().z + multi[j].z ) &&
( zmin <= pi->pos().z + multi[j].z + tile.height ) )
{
if( tile.isBlocking() || tile.isRoofOrFloorTile() )
{
return false;
}
}
}
}
++mit;
}
//Console::instance()->send( QString( "after multis\n" ) );
++pit;
}
return true;
}
}
bool exportFontBin(const char * filename, MFont * font)
{
if(! font)
return false;
MEngine * engine = MEngine::getInstance();
MRenderingContext * render = engine->getRenderingContext();
// read image
MImage image;
render->bindTexture(font->getTextureId());
render->getTexImage(0, &image);
unsigned int width = image.getWidth();
unsigned int height = image.getHeight();
if(width == 0 && height == 0)
{
printf("Error : unable to create image font for %s\n", filename);
return false;
}
// create file
FILE * file = fopen(filename, "wb");
if(! file)
{
printf("Error : can't create file %s\n", filename);
return false;
}
// bin
fwrite(M_FONT_HEADER, sizeof(char), 8, file);
// version
int version = 1;
fwrite(&version, sizeof(int), 1, file);
// font size
unsigned int fontSize = font->getFontSize();
fwrite(&fontSize, sizeof(int), 1, file);
// write image
{
fwrite(&width, sizeof(int), 1, file);
fwrite(&height, sizeof(int), 1, file);
unsigned char color[4];
unsigned int x, y;
for(y=0; y<height; y++)
{
for(x=0; x<width; x++)
{
image.readPixel(x, y, color);
fwrite(&color[3], sizeof(char), 1, file);
}
}
}
// write characters infos
{
map <unsigned int, MCharacter> * characters = font->getCharacters();
// size
unsigned int size = font->getCharactersNumber();
fwrite(&size, sizeof(int), 1, file);
// characters
map <unsigned int, MCharacter>::iterator
mit (characters->begin()),
mend(characters->end());
for(;mit!=mend;++mit)
{
unsigned int charCode = mit->first;
MCharacter * character = &mit->second;
MVector2 pos = character->getPos();
MVector2 offset = character->getOffset();
MVector2 scale = character->getScale();
float xadvance = character->getXAdvance();
fwrite(&charCode, sizeof(int), 1, file);
fwrite(&pos, sizeof(float), 2, file);
fwrite(&offset, sizeof(float), 2, file);
fwrite(&scale, sizeof(float), 2, file);
fwrite(&xadvance, sizeof(float), 1, file);
}
}
fclose(file);
return true;
}
// Mesh bin export
bool exportMeshBin(const char * filename, MMesh * mesh)
{
int version = 2;
char rep[256];
bool state;
// create file
MFile * file = M_fopen(filename, "wb");
if(! file)
{
printf("Error : can't create file %s\n", filename);
return false;
}
// get file directory
getRepertory(rep, filename);
// header
M_fwrite(M_MESH_HEADER, sizeof(char), 8, file);
// version
M_fwrite(&version, sizeof(int), 1, file);
// Animation
{
// anim refs
MArmatureAnimRef * armatureAnimRef = mesh->getArmatureAnimRef();
MTexturesAnimRef * texturesAnimRef = mesh->getTexturesAnimRef();
MMaterialsAnimRef * materialsAnimRef = mesh->getMaterialsAnimRef();
// armature anim ref
writeDataRef(file, armatureAnimRef, rep);
// textures anim ref
writeDataRef(file, texturesAnimRef, rep);
// materials anim ref
writeDataRef(file, materialsAnimRef, rep);
// anims ranges
unsigned int animsRangesNumber = mesh->getAnimsRangesNumber();
MAnimRange * animsRanges = mesh->getAnimsRanges();
M_fwrite(&animsRangesNumber, sizeof(int), 1, file);
if(animsRangesNumber > 0)
M_fwrite(animsRanges, sizeof(MAnimRange), animsRangesNumber, file);
}
// Textures
{
unsigned int t, texturesNumber = mesh->getTexturesNumber();
M_fwrite(&texturesNumber, sizeof(int), 1, file);
for(t=0; t<texturesNumber; t++)
{
MTexture * texture = mesh->getTexture(t);
MTextureRef * textureRef = texture->getTextureRef();
M_TEX_GEN_MODES genMode = texture->getGenMode();
M_WRAP_MODES UWrapMode = texture->getUWrapMode();
M_WRAP_MODES VWrapMode = texture->getVWrapMode();
MVector2 texTranslate = texture->getTexTranslate();
MVector2 texScale = texture->getTexScale();
float texRotate = texture->getTexRotate();
// texture ref
writeDataRef(file, textureRef, rep);
if(textureRef)
{
bool mipmap = textureRef->isMipmapEnabled();
M_fwrite(&mipmap, sizeof(bool), 1, file);
}
// data
M_fwrite(&genMode, sizeof(M_TEX_GEN_MODES), 1, file);
M_fwrite(&UWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&VWrapMode, sizeof(M_WRAP_MODES), 1, file);
M_fwrite(&texTranslate, sizeof(MVector2), 1, file);
M_fwrite(&texScale, sizeof(MVector2), 1, file);
M_fwrite(&texRotate, sizeof(float), 1, file);
}
}
// Materials
{
unsigned int m, materialsNumber = mesh->getMaterialsNumber();
M_fwrite(&materialsNumber, sizeof(int), 1, file);
for(m=0; m<materialsNumber; m++)
{
MMaterial * material = mesh->getMaterial(m);
int type = material->getType();
float opacity = material->getOpacity();
float shininess = material->getShininess();
float customValue = material->getCustomValue();
M_BLENDING_MODES blendMode = material->getBlendMode();
MVector3 emit = material->getEmit();
MVector3 diffuse = material->getDiffuse();
MVector3 specular = material->getSpecular();
MVector3 customColor = material->getCustomColor();
MFXRef * FXRef = material->getFXRef();
MFXRef * ZFXRef = material->getZFXRef();
// FX ref
state = FXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(FXRef)
{
MShaderRef * vertShadRef = FXRef->getVertexShaderRef();
MShaderRef * pixShadRef = FXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// Z FX ref
state = ZFXRef != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(ZFXRef)
{
MShaderRef * vertShadRef = ZFXRef->getVertexShaderRef();
MShaderRef * pixShadRef = ZFXRef->getPixelShaderRef();
writeDataRef(file, vertShadRef, rep);
writeDataRef(file, pixShadRef, rep);
}
// data
M_fwrite(&type, sizeof(int), 1, file);
M_fwrite(&opacity, sizeof(float), 1, file);
M_fwrite(&shininess, sizeof(float), 1, file);
M_fwrite(&customValue, sizeof(float), 1, file);
M_fwrite(&blendMode, sizeof(M_BLENDING_MODES), 1, file);
M_fwrite(&emit, sizeof(MVector3), 1, file);
M_fwrite(&diffuse, sizeof(MVector3), 1, file);
M_fwrite(&specular, sizeof(MVector3), 1, file);
M_fwrite(&customColor, sizeof(MVector3), 1, file);
// textures pass
unsigned int t, texturesPassNumber = material->getTexturesPassNumber();
M_fwrite(&texturesPassNumber, sizeof(int), 1, file);
for(t=0; t<texturesPassNumber; t++)
{
MTexturePass * texturePass = material->getTexturePass(t);
MTexture * texture = texturePass->getTexture();
unsigned int mapChannel = texturePass->getMapChannel();
M_TEX_COMBINE_MODES combineMode = texturePass->getCombineMode();
// texture id
int textureId = getTextureId(mesh, texture);
M_fwrite(&textureId, sizeof(int), 1, file);
// data
M_fwrite(&mapChannel, sizeof(int), 1, file);
M_fwrite(&combineMode, sizeof(M_TEX_COMBINE_MODES), 1, file);
}
}
}
// Bones
{
MArmature * armature = mesh->getArmature();
state = armature != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(armature)
{
unsigned int b, bonesNumber = armature->getBonesNumber();
M_fwrite(&bonesNumber, sizeof(int), 1, file);
for(b=0; b<bonesNumber; b++)
{
MOBone * bone = armature->getBone(b);
MObject3d * parent = bone->getParent();
MVector3 position = bone->getPosition();
MVector3 scale = bone->getScale();
MQuaternion rotation = bone->getRotation();
// name
writeString(file, bone->getName());
// parent id
int parentId = -1;
if(parent)
{
unsigned int id;
if(armature->getBoneId(parent->getName(), &id))
parentId = (int)id;
}
M_fwrite(&parentId, sizeof(int), 1, file);
// position / rotation / scale
M_fwrite(&position, sizeof(MVector3), 1, file);
M_fwrite(&rotation, sizeof(MQuaternion), 1, file);
M_fwrite(&scale, sizeof(MVector3), 1, file);
}
}
}
// BoundingBox
{
MBox3d * box = mesh->getBoundingBox();
M_fwrite(box, sizeof(MBox3d), 1, file);
}
// SubMeshs
{
unsigned int s, subMeshsNumber = mesh->getSubMeshsNumber();
MSubMesh * subMeshs = mesh->getSubMeshs();
M_fwrite(&subMeshsNumber, sizeof(int), 1, file);
for(s=0; s<subMeshsNumber; s++)
{
MSubMesh * subMesh = &(subMeshs[s]);
unsigned int indicesSize = subMesh->getIndicesSize();
unsigned int verticesSize = subMesh->getVerticesSize();
unsigned int normalsSize = subMesh->getNormalsSize();
unsigned int tangentsSize = subMesh->getTangentsSize();
unsigned int texCoordsSize = subMesh->getTexCoordsSize();
unsigned int colorsSize = subMesh->getColorsSize();
M_TYPES indicesType = subMesh->getIndicesType();
void * indices = subMesh->getIndices();
MColor * colors = subMesh->getColors();
MVector3 * vertices = subMesh->getVertices();
MVector3 * normals = subMesh->getNormals();
MVector3 * tangents = subMesh->getTangents();
MVector2 * texCoords = subMesh->getTexCoords();
MBox3d * box = subMesh->getBoundingBox();
MSkinData * skin = subMesh->getSkinData();
map<unsigned int, unsigned int> * mapChannelOffsets = subMesh->getMapChannelOffsets();
// BoundingBox
M_fwrite(box, sizeof(MBox3d), 1, file);
// indices
M_fwrite(&indicesSize, sizeof(int), 1, file);
if(indicesSize > 0)
{
// indice type
M_fwrite(&indicesType, sizeof(M_TYPES), 1, file);
switch(indicesType)
{
case M_USHORT:
M_fwrite(indices, sizeof(short), indicesSize, file);
break;
case M_UINT:
M_fwrite(indices, sizeof(int), indicesSize, file);
break;
}
}
// vertices
M_fwrite(&verticesSize, sizeof(int), 1, file);
if(verticesSize > 0)
M_fwrite(vertices, sizeof(MVector3), verticesSize, file);
// normals
M_fwrite(&normalsSize, sizeof(int), 1, file);
if(normalsSize > 0)
M_fwrite(normals, sizeof(MVector3), normalsSize, file);
// tangents
M_fwrite(&tangentsSize, sizeof(int), 1, file);
if(tangentsSize > 0)
M_fwrite(tangents, sizeof(MVector3), tangentsSize, file);
// texCoords
M_fwrite(&texCoordsSize, sizeof(int), 1, file);
if(texCoordsSize > 0)
M_fwrite(texCoords, sizeof(MVector2), texCoordsSize, file);
// colors
M_fwrite(&colorsSize, sizeof(int), 1, file);
if(colorsSize > 0)
M_fwrite(colors, sizeof(MColor), colorsSize, file);
// mapChannels
{
unsigned int size = mapChannelOffsets->size();
M_fwrite(&size, sizeof(int), 1, file);
map<unsigned int, unsigned int>::iterator
mit (mapChannelOffsets->begin()),
mend(mapChannelOffsets->end());
for(;mit!=mend;++mit)
{
M_fwrite(&mit->first, sizeof(int), 1, file);
M_fwrite(&mit->second, sizeof(int), 1, file);
}
}
// Skins
state = skin != NULL;
M_fwrite(&state, sizeof(bool), 1, file);
if(skin)
{
// skin point
unsigned int p, pointsNumber = skin->getPointsNumber();
M_fwrite(&pointsNumber, sizeof(int), 1, file);
for(p=0; p<pointsNumber; p++)
{
MSkinPoint * skinPoint = skin->getPoint(p);
unsigned int vertexId = skinPoint->getVertexId();
unsigned int bonesNumber = skinPoint->getBonesNumber();
unsigned short * bonesIds = skinPoint->getBonesIds();
float * bonesWeights = skinPoint->getBonesWeights();
// data
M_fwrite(&vertexId, sizeof(int), 1, file);
M_fwrite(&bonesNumber, sizeof(int), 1, file);
if(bonesNumber > 0)
{
M_fwrite(bonesIds, sizeof(short), bonesNumber, file);
M_fwrite(bonesWeights, sizeof(float), bonesNumber, file);
}
}
}
// Displays
unsigned int d, displaysNumber = subMesh->getDisplaysNumber();
M_fwrite(&displaysNumber, sizeof(int), 1, file);
for(d=0; d<displaysNumber; d++)
{
MDisplay * display = subMesh->getDisplay(d);
M_PRIMITIVE_TYPES primitiveType = display->getPrimitiveType();
unsigned int begin = display->getBegin();
unsigned int size = display->getSize();
MMaterial * material = display->getMaterial();
M_CULL_MODES cullMode = display->getCullMode();
int materialId = getMaterialId(mesh, material);
// data
M_fwrite(&primitiveType, sizeof(M_PRIMITIVE_TYPES), 1, file);
M_fwrite(&begin, sizeof(int), 1, file);
M_fwrite(&size, sizeof(int), 1, file);
M_fwrite(&materialId, sizeof(int), 1, file);
M_fwrite(&cullMode, sizeof(M_CULL_MODES), 1, file);
}
}
}
M_fclose(file);
return true;
}
