void MemoryManager::collect() {
if (!RuntimeOption::EvalEnableGC || empty()) return;
Marker mkr;
mkr.init();
mkr.trace();
mkr.sweep();
}
// Sync method.
void qtractorTimeScale::sync ( const qtractorTimeScale& ts )
{
// Copy master parameters...
m_iSampleRate = ts.m_iSampleRate;
m_iTicksPerBeat = ts.m_iTicksPerBeat;
m_iPixelsPerBeat = ts.m_iPixelsPerBeat;
// Copy location markers...
m_markers.clear();
Marker *pMarker = ts.m_markers.first();
while (pMarker) {
m_markers.append(new Marker(*pMarker));
pMarker = pMarker->next();
}
m_markerCursor.reset();
// Copy tempo-map nodes...
m_nodes.clear();
Node *pNode = ts.nodes().first();
while (pNode) {
m_nodes.append(new Node(this, pNode->frame,
pNode->tempo, pNode->beatType,
pNode->beatsPerBar, pNode->beatDivisor));
pNode = pNode->next();
}
m_cursor.reset();
updateScale();
}
Palette* MuseScore::newRepeatsPalette()
{
Palette* sp = new Palette;
sp->setName(QT_TRANSLATE_NOOP("Palette", "Repeats && Jumps"));
sp->setMag(0.65);
sp->setGrid(84, 28);
sp->setDrawGrid(true);
RepeatMeasure* rm = new RepeatMeasure(gscore);
sp->append(rm, tr("Repeat measure sign"));
for (int i = 0; i < markerTypeTableSize(); i++) {
if(markerTypeTable[i].type == Marker::Type::CODETTA) //not in smufl
continue;
Marker* mk = new Marker(gscore);
mk->setMarkerType(markerTypeTable[i].type);
sp->append(mk, qApp->translate("markerType", markerTypeTable[i].name.toUtf8().constData()));
}
for (int i = 0; i < jumpTypeTableSize(); i++) {
Jump* jp = new Jump(gscore);
jp->setJumpType(jumpTypeTable[i].type);
sp->append(jp, qApp->translate("jumpType", jumpTypeTable[i].userText.toUtf8().constData()));
}
return sp;
}
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);
}
}
}
int
MarkerSell::info (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *sell = (Marker *) pd->data;
Entity *e = sell->settings();
QVariant *price = e->get(QString("price"));
if (! price)
return 0;
QVariant *date = e->get(QString("date"));
if (! date)
return 0;
QDateTime dt = date->toDateTime();
pd->info << "D=" + dt.toString("yyyy-MM-dd");
pd->info << "T=" + dt.toString("HH:mm:ss");
Strip strip;
QString ts;
strip.strip(price->toDouble(), 4, ts);
pd->info << QString("Sell=") + ts;
return 1;
}
void Plot::mouseClick (int button, QPoint p)
{
if (! g_symbol)
return;
if (_plotSettings.selected)
{
_plotSettings.selected->click(_plotSettings.status, button, p);
return;
}
QHashIterator<QString, Marker *> it(_plotSettings.markers);
while (it.hasNext())
{
it.next();
Marker *co = it.value();
if (co->readOnly())
continue;
if (! co->isSelected(p))
continue;
_plotSettings.selected = co;
_plotSettings.selected->click(_plotSettings.status, button, p);
return;
}
}
int
MarkerTLine::highLow (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *tline = (Marker *) pd->data;
Entity *e = tline->settings();
PlotDateScaleDraw *dsd = (PlotDateScaleDraw *) tline->plot()->axisScaleDraw(QwtPlot::xBottom);
if (! dsd)
return 1;
QVariant *date = e->get(QString("date"));
if (! date)
return 0;
QVariant *date2 = e->get(QString("date2"));
if (! date2)
return 0;
QVariant *price = e->get(QString("price"));
if (! price)
return 0;
QVariant *price2 = e->get(QString("price2"));
if (! price2)
return 0;
int x = dsd->dateToX(date->toDateTime());
if (x >= pd->start && x <= pd->end)
{
pd->high = price->toDouble();
double t = price2->toDouble();
if (t > pd->high)
pd->high = t;
pd->low = price->toDouble();
if (t < pd->low)
pd->low = t;
return 1;
}
int x2 = dsd->dateToX(date2->toDateTime());
if (x2 >= pd->start && x2 <= pd->end)
{
pd->high = price->toDouble();
double t = price2->toDouble();
if (t > pd->high)
pd->high = t;
pd->low = price->toDouble();
if (t < pd->low)
pd->low = t;
return 1;
}
return 1;
}
void EditMarkerGroupDialog::sl_onTypeChanged(int newTypeIndex) {
if (newTypeIndex == currentTypeIndex) {
return;
}
MarkerDataType oldType = MarkerTypes::getDataTypeById(marker->getType());
MarkerDataType newType = MarkerTypes::getDataTypeById(typeIds.at(newTypeIndex));
bool changeMarker = false;
if (1 == marker->getValues().size()) { // contains only "rest"
changeMarker = true;
} else {
if (oldType == newType) {
changeMarker = true;
} else {
changeMarker = (QMessageBox::Ok == QMessageBox::question(this, tr("Warning"), tr("Are you really want to change marker's type? Some data can be lost!"), QMessageBox::Ok | QMessageBox::Cancel));
}
}
if (changeMarker) {
Marker *oldMarker = marker;
marker = MarkerFactory::createInstanse(typeIds.at(newTypeIndex), addParamEdit->text());
{
marker->setName(oldMarker->getName());
MarkerDataType oldType = MarkerTypes::getDataTypeById(oldMarker->getType());
MarkerDataType newType = MarkerTypes::getDataTypeById(marker->getType());
if (oldType == newType) {
foreach (const QString &key, oldMarker->getValues().keys()) {
marker->addValue(key, oldMarker->getValues().value(key));
}
} else {
marker->addValue(MarkerUtils::REST_OPERATION, oldMarker->getValues().value(MarkerUtils::REST_OPERATION));
}
}
bool IdentificatorTemplMatch::readMarkerCode(const cv::Mat &area, Marker &marker) {
assert(area.rows == area.cols && area.rows == reqMarkerSize && area.type() == CV_8UC1); // must be quadratic and grayscale
// check the border as "cells" first
bool borderOk = checkBorder(area, 0, 0) // top row
&& checkBorder(area, 0, 7) // bottom row
&& checkBorder(area, 1, 0) // left column
&& checkBorder(area, 1, 7); // right column
if (!borderOk) return false;
// printf("ocv_ar::IdentificatorTemplMatch - border checks ok\n");
// get only the "content" of <area>, i.e. the marker without borders
int areaContentSize = area.cols - 2 * borderSize;
cv::Rect roi(borderSize, borderSize, areaContentSize, areaContentSize);
cv::Mat areaContent(area, roi);
// do the template matching for all templates we have
for (TemplateMap::iterator it = templates.begin();
it != templates.end();
++it)
{
int validRot;
if (checkTemplateRotations(areaContent, it->second, &validRot)) { // found a matching template!
marker.setId(it->first);
marker.rotatePoints(validRot);
return true;
}
}
return false;
}
ClientData Graph::pickEntry(int xx, int yy, ClassId* classIdPtr)
{
if (flags & (LAYOUT | MAP_MARKERS)) {
*classIdPtr = CID_NONE;
return NULL;
}
// Sample coordinate is in one of the graph margins. Can only pick an axis.
Region2d exts;
extents(&exts);
if (xx>=exts.right || xx<exts.left || yy>=exts.bottom || yy<exts.top) {
Axis* axisPtr = nearestAxis(xx, yy);
if (axisPtr) {
*classIdPtr = axisPtr->classId();
return axisPtr;
}
}
// From top-to-bottom check:
// 1. markers drawn on top (-under false).
// 2. elements using its display list back to front.
// 3. markers drawn under element (-under true).
Marker* markerPtr = nearestMarker(xx, yy, 0);
if (markerPtr) {
*classIdPtr = markerPtr->classId();
return markerPtr;
}
GraphOptions* ops = (GraphOptions*)ops_;
ClosestSearch* searchPtr = &ops->search;
searchPtr->index = -1;
searchPtr->x = xx;
searchPtr->y = yy;
searchPtr->dist = (double)(searchPtr->halo + 1);
for (ChainLink* link = Chain_LastLink(elements_.displayList); link;
link = Chain_PrevLink(link)) {
Element* elemPtr = (Element*)Chain_GetValue(link);
ElementOptions* eops = (ElementOptions*)elemPtr->ops();
if (eops->hide)
continue;
elemPtr->closest();
}
// Found an element within the minimum halo distance.
if (searchPtr->dist <= (double)searchPtr->halo) {
*classIdPtr = searchPtr->elemPtr->classId();
return searchPtr->elemPtr;
}
markerPtr = nearestMarker(xx, yy, 1);
if (markerPtr) {
*classIdPtr = markerPtr->classId();
return markerPtr;
}
*classIdPtr = CID_NONE;
return NULL;
}
void MemoryManager::traceHeap() {
if (!RuntimeOption::EvalTraceHeap) return;
if (empty()) return;
Marker mkr;
mkr.init();
mkr.trace();
mkr.sweep();
}
Marker::Marker(const Marker &m)
:m_id(m.getID())
{
for(int i=0; i<16; i++)
{
m_position[i]=m.getTransformation()[i];
}
}
void Graph::configureMarkers()
{
for (ChainLink* link = Chain_FirstLink(markers_.displayList); link;
link = Chain_NextLink(link)) {
Marker* markerPtr = (Marker*)Chain_GetValue(link);
markerPtr->configure();
}
}
// Markers
void OpenSimContext::setBody(Marker& currentMarker, Body& newBody, bool b) {
if( b ) {
currentMarker.changeFramePreserveLocation( *_configState, newBody );
} else {
currentMarker.changeFrame( newBody );
}
return;
}
void SeriesList::drawInFrame(Frame& innerFrame, double minX, double maxX, double minY, double maxY)
{
double multX = innerFrame.getWidth()/(maxX-minX);
double multY = innerFrame.getHeight()/(maxY-minY);
// Draw lines
for(int i=0;i<getNumSeries();i++)
{
innerFrame.push_state();
StrokeStyle s = getStyle(i);
Marker m = getMarker(i);
if(m.getColor().isClear() && s.getColor().isClear())
{
innerFrame << Comment("Plot contained data with clear stroke and marker. Skipping.");
continue;
}
vector< pair<double,double> >& vec = getPointList(i);
Path curve(vec,innerFrame.lx(), innerFrame.ly());
// What I'd give for a line of haskell...
// map (\(x,y) -> (multX*(x-minX), multY*(y-minY))) vector
map_object map_instance(multX,minX,multY,minY);
innerFrame.setMarker(m);
innerFrame.setLineStyle(s);
if(s.getColor().isClear())
{
// crop
auto_ptr< Path > cropX = Splitter::cropToBox(minX,maxX,minY,maxY,curve);
// Fit it to the box.
std::for_each(cropX->begin(), cropX->end(), map_instance);
// Draw the line
innerFrame.line(*cropX);
}
else
{
// interpolate
auto_ptr< std::list<Path> > interpX = Splitter::interpToBox(minX,maxX,minY,maxY,curve);
for(std::list<Path>::iterator i=interpX->begin();i!=interpX->end();i++)
{
// Fit it to the box
std::for_each(i->begin(), i->end(), map_instance);
// Draw the line
innerFrame.line(*i);
}
}
innerFrame.pop_state();
}
}
void Plot::mouseMove (QPoint p)
{
// qDebug() << "mouse move";
if (! _plotSettings.info)
return;
if (! g_symbol)
return;
if (_plotSettings.selected)
{
_plotSettings.selected->move(_plotSettings.status, p);
return;
}
QHashIterator<QString, Marker *> it2(_plotSettings.markers);
while (it2.hasNext())
{
it2.next();
Marker *m = it2.value();
if (! m->isSelected(p))
continue;
QStringList info;
info << _plotSettings.name;
if (! m->info(info))
continue;
_plotInfo->setData(info);
replot();
return;
}
int index = (int) invTransform(QwtPlot::xBottom, p.x());
QStringList info;
info << _plotSettings.name;
_dateScaleDraw->info(index, info);
QHashIterator<QString, Curve *> it(_plotSettings.curves);
while (it.hasNext())
{
it.next();
Curve *curve = it.value();
curve->info(index, info);
}
_plotInfo->setData(info);
replot();
}
AntState* DroppingMarker::update()
{
properties_.currentMarker = NULL;
if(!hasTooCloseMarker()) {
Marker* dropped = properties_.robot->dropMarker();
properties_.currentMarker = dropped;
LOG(DEBUG) << "-- dropped marker id " << dropped->getID() << " (" << properties_.robot->getName() << ")";
}
return new SelectingTarget(properties_);
}
int
MarkerTLine::create (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *tline = (Marker *) pd->data;
pd->status = PlotStatus::_CREATE_MOVE;
tline->setSelected(TRUE);
emit signalMessage(tr("Place TLine marker..."));
return 1;
}
int
MarkerSell::create (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *sell = (Marker *) pd->data;
pd->status = PlotStatus::_MOVE;
sell->setSelected(TRUE);
emit signalMessage(QObject::tr("Place Sell marker"));
return 1;
}
int
MarkerRetracement::create (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *m = (Marker *) pd->data;
pd->status = PlotStatus::_CREATE_MOVE;
m->setSelected(TRUE);
emit signalMessage(tr("Select highest starting point..."));
return 1;
}
LibInfo read_lib(const fs::path& path)
{
std::fstream fs(path, std::ios::in | std::ios::binary | std::ios::ate);
Checks::check_exit(VCPKG_LINE_INFO, fs.is_open(), "Could not open file %s for reading", path.generic_string());
read_and_verify_archive_file_signature(fs);
Marker marker;
marker.set_to_current_pos(fs);
// First Linker Member
const ArchiveMemberHeader first_linker_member_header = ArchiveMemberHeader::read(fs);
Checks::check_exit(VCPKG_LINE_INFO,
first_linker_member_header.name().substr(0, 2) == "/ ",
"Could not find proper first linker member");
marker.advance_by(ArchiveMemberHeader::HEADER_SIZE + first_linker_member_header.member_size());
marker.seek_to_marker(fs);
const ArchiveMemberHeader second_linker_member_header = ArchiveMemberHeader::read(fs);
Checks::check_exit(VCPKG_LINE_INFO,
second_linker_member_header.name().substr(0, 2) == "/ ",
"Could not find proper second linker member");
// The first 4 bytes contains the number of archive members
const auto archive_member_count = read_value_from_stream<uint32_t>(fs);
const OffsetsArray offsets = OffsetsArray::read(fs, archive_member_count);
marker.advance_by(ArchiveMemberHeader::HEADER_SIZE + second_linker_member_header.member_size());
marker.seek_to_marker(fs);
const bool has_longname_member_header = peek_value_from_stream<uint16_t>(fs) == 0x2F2F;
if (has_longname_member_header)
{
const ArchiveMemberHeader longnames_member_header = ArchiveMemberHeader::read(fs);
marker.advance_by(ArchiveMemberHeader::HEADER_SIZE + longnames_member_header.member_size());
marker.seek_to_marker(fs);
}
std::set<MachineType> machine_types;
// Next we have the obj and pseudo-object files
for (const uint32_t offset : offsets.data)
{
marker.set_to_offset(offset + ArchiveMemberHeader::HEADER_SIZE); // Skip the header, no need to read it.
marker.seek_to_marker(fs);
const auto first_two_bytes = peek_value_from_stream<uint16_t>(fs);
const bool is_import_header = to_machine_type(first_two_bytes) == MachineType::UNKNOWN;
const MachineType machine =
is_import_header ? ImportHeader::read(fs).machine_type() : CoffFileHeader::read(fs).machine_type();
machine_types.insert(machine);
}
return {std::vector<MachineType>(machine_types.cbegin(), machine_types.cend())};
}
bool MarkerGroupListCfgModel::removeRows(int row, int count, const QModelIndex &) {
if (1 != count) {
return true;
}
Marker *toRemove = markers.at(row);
QString markerName = toRemove->getName();
beginRemoveRows(QModelIndex(), row, row+count-1);
markers.removeAt(row);
endRemoveRows();
emit si_markerRemoved(markerName);
return true;
}
void Marker::copyTo(Marker &m)const{
m.id=id;
// size of the markers sides in meters
m.ssize=ssize;
// matrices of rotation and translation respect to the camera
Rvec.copyTo(m.Rvec );
Tvec.copyTo(m.Tvec);
m.resize(size());
for(size_t i=0;i<size();i++)
m.at(i)=at(i);
m.dict_info=dict_info;
m.contourPoints=contourPoints;
}
void MarkerDetectorImpl::TrackMarkerAdd(int id, PointDouble corners[4]) {
Marker *mn = new_M(edge_length, res, margin);
if (map_edge_length.find(id) != map_edge_length.end()) {
mn->SetMarkerSize(map_edge_length[id], res, margin);
}
mn->SetId(id);
mn->marker_corners_img.clear();
mn->marker_corners_img.push_back(corners[0]);
mn->marker_corners_img.push_back(corners[1]);
mn->marker_corners_img.push_back(corners[2]);
mn->marker_corners_img.push_back(corners[3]);
_track_markers_push_back(mn);
delete mn;
}
void SAS::report_marker(const Marker& marker, Marker::Scope scope)
{
if (_connection)
{
_connection->send_msg(marker.to_string(scope));
}
}
void collectImpl(const char* phase) {
VMRegAnchor _;
if (t_eager_gc && RuntimeOption::EvalFilterGCPoints) {
t_eager_gc = false;
auto pc = vmpc();
if (t_surprise_filter.test(pc)) return;
t_surprise_filter.insert(pc);
TRACE(2, "eager gc %s at %p\n", phase, pc);
} else {
TRACE(2, "normal gc %s at %p\n", phase, vmpc());
}
Marker mkr;
mkr.init();
mkr.trace();
mkr.sweep();
}
void MarkerRenderer::_render( const Marker& marker )
{
if ( !_texture.isValid() && !_generateTexture( ))
return;
const QPointF pos = marker.getPosition();
glPushAttrib( GL_ENABLE_BIT | GL_TEXTURE_BIT );
glDisable( GL_DEPTH_TEST );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glPushMatrix();
glTranslatef( pos.x(), pos.y(), 0.f );
glScalef( MARKER_SIZE_PIXELS, MARKER_SIZE_PIXELS, 1.f );
glTranslatef( -0.5f, -0.5f, 0.f ); // Center unit quad
_quad.setTexture( _texture.getTextureId( ));
_quad.render();
glPopMatrix();
glPopAttrib();
}
void Graph::drawMarkers(Drawable drawable, int under)
{
for (ChainLink* link = Chain_LastLink(markers_.displayList); link;
link = Chain_PrevLink(link)) {
Marker* markerPtr = (Marker*)Chain_GetValue(link);
MarkerOptions* mops = (MarkerOptions*)markerPtr->ops();
if ((mops->drawUnder != under) || markerPtr->clipped_ || mops->hide)
continue;
if (isElementHidden(markerPtr))
continue;
markerPtr->draw(drawable);
}
}
void MarkerEditor::sl_onMarkerAdded(const QString &markerName) {
Marker *marker = markerModel->getMarker(markerName);
SAFE_POINT(NULL != marker, "NULL marker", );
{ // TODO: make common way to get marked object output port
assert(1 == cfg->getOutputPorts().size());
Port *outPort = cfg->getOutputPorts().at(0);
assert(outPort->getOutputType()->isMap());
QMap<Descriptor, DataTypePtr> outTypeMap = outPort->getOutputType()->getDatatypesMap();
Descriptor newSlot = MarkerSlots::getSlotByMarkerType(marker->getType(), marker->getName());
outTypeMap[newSlot] = BaseTypes::STRING_TYPE();
DataTypePtr newType(new MapDataType(dynamic_cast<Descriptor&>(*(outPort->getType())), outTypeMap));
outPort->setNewType(newType);
}
}
bool Marker::equals( const Marker& other ) const
{
/*
* \note these first two are commented as the basic shape ability has been
* removed from marker at this point.
*/
// This gets too complicated to check.
//if ( !usesDefault ) return false;
// This one default, other not.
//if ( !other.hasDefaultMark() ) return false;
return ((this->shapeEquals(other)) && (markerColor == other.getColor()));
// Check if the marks are different.
//if ( mark != other.getMark() ) return false;
// Check if the mark colors are different.
//if ( markerColor != other.getColor() ) return false;
// Check if the ranges are different
//if ( range != other.getRange() ) return false;
// Bothe use the same default mark and color.
//return true;
}
