Qgs25DRendererWidget::Qgs25DRendererWidget( QgsVectorLayer* layer, QgsStyleV2* style, QgsFeatureRendererV2* renderer )
: QgsRendererV2Widget( layer, style )
, mRenderer( nullptr )
{
if ( !layer )
return;
// the renderer only applies to point vector layers
if ( layer->geometryType() != QGis::Polygon )
{
//setup blank dialog
QGridLayout* layout = new QGridLayout( this );
QLabel* label = new QLabel( tr( "The 2.5D renderer only can be used with polygon layers. \n"
"'%1' is not a polygon layer and cannot be rendered in 2.5D." )
.arg( layer->name() ), this );
layout->addWidget( label );
return;
}
setupUi( this );
if ( renderer )
{
mRenderer = Qgs25DRenderer::convertFromRenderer( renderer );
}
mHeightWidget->setLayer( layer );
QgsExpressionContextScope* scope = QgsExpressionContextUtils::layerScope( mLayer );
QVariant height = scope->variable( "qgis_25d_height" );
QVariant angle = scope->variable( "qgis_25d_angle" );
delete scope;
mHeightWidget->setField( height.isNull() ? "10" : height.toString() );
mAngleWidget->setValue( angle.isNull() ? 70 : angle.toDouble() );
mWallColorButton->setColor( mRenderer->wallColor() );
mRoofColorButton->setColor( mRenderer->roofColor() );
mShadowColorButton->setColor( mRenderer->shadowColor() );
mShadowEnabledWidget->setChecked( mRenderer->shadowEnabled() );
mShadowSizeWidget->setValue( mRenderer->shadowSpread() );
mWallExpositionShading->setChecked( mRenderer->wallShadingEnabled() );
connect( mAngleWidget, SIGNAL( valueChanged( int ) ), this, SLOT( updateRenderer() ) );
connect( mHeightWidget, SIGNAL( fieldChanged( QString ) ), this, SLOT( updateRenderer() ) );
connect( mWallColorButton, SIGNAL( colorChanged( QColor ) ), this, SLOT( updateRenderer() ) );
connect( mRoofColorButton, SIGNAL( colorChanged( QColor ) ), this, SLOT( updateRenderer() ) );
connect( mShadowColorButton, SIGNAL( colorChanged( QColor ) ), this, SLOT( updateRenderer() ) );
connect( mShadowEnabledWidget, SIGNAL( toggled( bool ) ), this, SLOT( updateRenderer() ) );
connect( mShadowSizeWidget, SIGNAL( valueChanged( double ) ), this, SLOT( updateRenderer() ) );
connect( mWallExpositionShading, SIGNAL( toggled( bool ) ), this, SLOT( updateRenderer() ) );
}
unsigned CharacterData::parserAppendData(const UChar* data, unsigned dataLength, unsigned lengthLimit)
{
unsigned oldLength = m_data.length();
unsigned end = min(dataLength, lengthLimit - oldLength);
// Check that we are not on an unbreakable boundary.
// Some text break iterator implementations work best if the passed buffer is as small as possible,
// see <https://bugs.webkit.org/show_bug.cgi?id=29092>.
// We need at least two characters look-ahead to account for UTF-16 surrogates.
if (end < dataLength) {
NonSharedCharacterBreakIterator it(data, (end + 2 > dataLength) ? dataLength : end + 2);
if (!isTextBreak(it, end))
end = textBreakPreceding(it, end);
}
if (!end)
return 0;
m_data.append(data, end);
updateRenderer(oldLength, 0);
document()->incDOMTreeVersion();
// We don't call dispatchModifiedEvent here because we don't want the
// parser to dispatch DOM mutation events.
if (parentNode())
parentNode()->childrenChanged();
return end;
}
void ImageLoader::notifyFinished(Resource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (!hasPendingBeforeLoadEvent())
updateRenderer();
if (!m_hasPendingLoadEvent)
return;
if (resource->errorOccurred()) {
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(this);
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
if (resource->wasCanceled()) {
m_hasPendingLoadEvent = false;
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
loadEventSender().dispatchEventSoon(this);
}
void ImageLoader::notifyFinished(CachedResource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (haveFiredBeforeLoadEvent())
updateRenderer();
if (m_firedLoad)
return;
if (m_element->fastHasAttribute(HTMLNames::crossoriginAttr) && !resource->passesAccessControlCheck(m_element->document()->securityOrigin())) {
setImage(0);
DEFINE_STATIC_LOCAL(String, consoleMessage, ("Cross-origin image load denied by Cross-Origin Resource Sharing policy."));
m_element->document()->addMessage(JSMessageSource, LogMessageType, ErrorMessageLevel, consoleMessage, 1, String(), 0);
ASSERT(m_firedLoad);
return;
}
if (resource->wasCanceled()) {
m_firedLoad = true;
return;
}
loadEventSender().dispatchEventSoon(this);
}
void ImageLoader::dispatchPendingBeforeLoadEvent()
{
if (!m_hasPendingBeforeLoadEvent)
return;
if (!m_image)
return;
if (!element().document().hasLivingRenderTree())
return;
m_hasPendingBeforeLoadEvent = false;
if (element().dispatchBeforeLoadEvent(m_image->url())) {
updateRenderer();
return;
}
if (m_image) {
m_image->removeClient(this);
m_image = nullptr;
}
loadEventSender().cancelEvent(*this);
m_hasPendingLoadEvent = false;
if (is<HTMLObjectElement>(element()))
downcast<HTMLObjectElement>(element()).renderFallbackContent();
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
}
void ImageLoader::dispatchPendingBeforeLoadEvent()
{
if (!m_hasPendingBeforeLoadEvent)
return;
if (!m_image)
return;
if (!m_element->document()->attached())
return;
m_hasPendingBeforeLoadEvent = false;
if (m_element->dispatchBeforeLoadEvent(m_image->url())) {
updateRenderer();
return;
}
if (m_image) {
m_image->removeClient(this);
m_image = 0;
}
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
if (m_element->hasTagName(HTMLNames::objectTag))
static_cast<HTMLObjectElement*>(m_element)->renderFallbackContent();
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
}
void CharacterData::setDataAndUpdate(PassRefPtr<StringImpl> newData, unsigned offsetOfReplacedData, unsigned oldLength, unsigned newLength)
{
if (document()->frame())
document()->frame()->selection()->textWillBeReplaced(this, offsetOfReplacedData, oldLength, newLength);
RefPtr<StringImpl> oldData = m_data;
m_data = newData;
updateRenderer(offsetOfReplacedData, oldLength);
dispatchModifiedEvent(oldData.get());
}
void ImageLoader::notifyFinished(CachedResource*)
{
ASSERT(m_failedLoadURL.isEmpty());
m_imageComplete = true;
if (haveFiredBeforeLoadEvent())
updateRenderer();
loadEventSender().dispatchEventSoon(this);
}
void CharacterData::setDataAndUpdate(const String& newData, unsigned offsetOfReplacedData, unsigned oldLength, unsigned newLength)
{
if (document()->frame())
document()->frame()->selection()->textWillBeReplaced(this, offsetOfReplacedData, oldLength, newLength);
String oldData = m_data;
m_data = newData;
updateRenderer(offsetOfReplacedData, oldLength);
document()->incDOMTreeVersion();
dispatchModifiedEvent(oldData);
}
void ImageLoader::notifyFinished(CachedResource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (haveFiredBeforeLoadEvent())
updateRenderer();
if (m_firedLoad)
return;
if (resource->wasCanceled())
return;
loadEventSender().dispatchEventSoon(this);
}
void ImageLoader::dispatchPendingBeforeLoadEvent()
{
if (m_firedBeforeLoad)
return;
if (!m_image)
return;
if (!m_element->document()->attached())
return;
m_firedBeforeLoad = true;
if (m_element->dispatchBeforeLoadEvent(m_image->url())) {
updateRenderer();
return;
}
if (m_image) {
m_image->removeClient(this);
m_image = 0;
}
loadEventSender().cancelEvent(this);
}
void Frame::preCommit(RenderContext &)
{
if (child("camera").hasChild("aspect") &&
child("frameBuffer")["size"].lastModified() >
child("camera")["aspect"].lastCommitted()) {
auto fbSize = child("frameBuffer")["size"].valueAs<vec2i>();
child("camera")["aspect"] = fbSize.x / float(fbSize.y);
}
auto rendererNode = child("renderer").nodeAs<Renderer>();
rendererNode->updateRenderer();
auto rHandle = rendererNode->valueAs<OSPRenderer>();
auto cHandle = child("camera").valueAs<OSPCamera>();
// XXX this is not sufficient (at least for FB):
// the FB can be released and re-created (i.e. on size change) and per
// (high) chance get the same handle (which is just the heap address when
// using the local device)
bool newRenderer = currentRenderer != rHandle;
bool newCamera = currentCamera != cHandle;
if (newRenderer)
currentRenderer = rHandle;
if (newCamera)
currentCamera = cHandle;
if (newRenderer || newCamera)
ospSetObject(rHandle, "camera", cHandle);
bool rChanged = rendererNode->subtreeModifiedButNotCommitted();
bool cChanged = child("camera").subtreeModifiedButNotCommitted();
clearFB = newCamera || newRenderer || rChanged || cChanged;
frameAccumulationLimit = child("frameAccumulationLimit").valueAs<int>();
// when frameAccumulationLimit is active, render at least 2 frames,
// otherwise the view is stuck showing the stale navigation framebuffer
// for no accumulation, disable the accumBuffer
if (frameAccumulationLimit >= 0)
frameAccumulationLimit = std::max(frameAccumulationLimit, 2);
}
void ImageLoader::notifyFinished(CachedResource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (!hasPendingBeforeLoadEvent())
updateRenderer();
if (!m_hasPendingLoadEvent)
return;
if (m_element->fastHasAttribute(HTMLNames::crossoriginAttr)
&& !m_element->document()->securityOrigin()->canRequest(image()->response().url())
&& !resource->passesAccessControlCheck(m_element->document()->securityOrigin())) {
setImageWithoutConsideringPendingLoadEvent(0);
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(this);
DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin image load denied by Cross-Origin Resource Sharing policy.")));
m_element->document()->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, consoleMessage);
ASSERT(!m_hasPendingLoadEvent);
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
if (resource->wasCanceled()) {
m_hasPendingLoadEvent = false;
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
loadEventSender().dispatchEventSoon(this);
}
void CharacterData::setDataAndUpdate(const String& newData, unsigned offsetOfReplacedData, unsigned oldLength, unsigned newLength)
{
#if ENABLE(UNDO_MANAGER)
if (UndoManager::isRecordingAutomaticTransaction(this)) {
const String& replacingData = newData.substring(offsetOfReplacedData, newLength);
const String& replacedData = m_data.substring(offsetOfReplacedData, oldLength);
UndoManager::addTransactionStep(DataReplacingDOMTransactionStep::create(this, offsetOfReplacedData, oldLength, replacingData, replacedData));
}
#endif
String oldData = m_data;
m_data = newData;
updateRenderer(offsetOfReplacedData, oldLength);
if (document()->frame())
document()->frame()->selection()->textWasReplaced(this, offsetOfReplacedData, oldLength, newLength);
document()->incDOMTreeVersion();
dispatchModifiedEvent(oldData);
}
void ImageLoader::notifyFinished(CachedResource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (!hasPendingBeforeLoadEvent())
updateRenderer();
if (!m_hasPendingLoadEvent)
return;
if (element().fastHasAttribute(HTMLNames::crossoriginAttr) && !resource->passesSameOriginPolicyCheck(*element().document().securityOrigin())) {
clearImageWithoutConsideringPendingLoadEvent();
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(*this);
static NeverDestroyed<String> consoleMessage(ASCIILiteral("Cross-origin image load denied by Cross-Origin Resource Sharing policy."));
element().document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
ASSERT(!m_hasPendingLoadEvent);
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
if (resource->wasCanceled()) {
m_hasPendingLoadEvent = false;
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
loadEventSender().dispatchEventSoon(*this);
}
void ImageLoader::dispatchPendingBeforeLoadEvent()
{
if (m_firedBeforeLoad)
return;
if (!m_image)
return;
if (!m_element->document()->attached())
return;
m_firedBeforeLoad = true;
if (m_element->dispatchBeforeLoadEvent(m_image->url())) {
updateRenderer();
return;
}
if (m_image) {
m_image->removeClient(this);
m_image = 0;
}
loadEventSender().cancelEvent(this);
if (m_element->hasTagName(HTMLNames::objectTag))
static_cast<HTMLObjectElement*>(m_element)->renderFallbackContent();
}
void iA3DLabelledVolumeVis::multiClassRendering( QList<QColor> const & classColors, QStandardItem* rootItem, double alpha )
{
double backAlpha = 0.00005;
double backRGB[3];
backRGB[0] = classColors.at(0).redF();
backRGB[1] = classColors.at(0).greenF();
backRGB[2] = classColors.at(0).blueF();
double red = 0.0;
double green = 0.0;
double blue = 0.0;
int CID = 0;
// clear existing points
oTF->RemoveAllPoints();
cTF->RemoveAllPoints();
// set background opacity and color
oTF->ClampingOff();
cTF->ClampingOff();
// Iterate through all classes to render, starting with 0 unclassified, 1 Class1,...
for (int i = 0; i < classColors.size(); i++)
{
red = classColors.at(i).redF();
green = classColors.at(i).greenF();
blue = classColors.at(i).blueF();
QStandardItem *item = rootItem->child(i, 0);
int itemL = item->rowCount();
// Class has no objects, proceed with next class
if (!itemL)
continue;
int hid = 0, next_hid = 1;
bool starting = false;
for (int j = 0; j < itemL; ++j)
{
hid = item->child(j, 0)->text().toInt();
if ((j + 1) < itemL)
{
next_hid = item->child(j + 1, 0)->text().toInt();
}
else
{
if (starting)
{
oTF->AddPoint(hid, alpha, 0.5, 1.0);
oTF->AddPoint(hid + 0.3, backAlpha, 0.5, 1.0);
cTF->AddRGBPoint(hid, red, green, blue, 0.5, 1.0);
cTF->AddRGBPoint(hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
break;
}
else
{
oTF->AddPoint(hid - 0.5, backAlpha, 0.5, 1.0);
oTF->AddPoint(hid, alpha, 0.5, 1.0);
cTF->AddRGBPoint(hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
cTF->AddRGBPoint(hid, red, green, blue, 0.5, 1.0);
oTF->AddPoint(hid + 0.3, backAlpha, 0.5, 1.0);
cTF->AddRGBPoint(hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
break;
}
}
//Create one single tooth
if (next_hid > hid + 1 && !starting)
{
oTF->AddPoint(hid - 0.5, backAlpha, 0.5, 1.0);
oTF->AddPoint(hid, alpha, 0.5, 1.0);
oTF->AddPoint(hid + 0.3, backAlpha, 0.5, 1.0);
cTF->AddRGBPoint(hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
cTF->AddRGBPoint(hid, red, green, blue, 0.5, 1.0);
cTF->AddRGBPoint(hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
}
else if (next_hid == hid + 1 && !starting)
{
starting = true;
oTF->AddPoint(hid - 0.5, backAlpha, 0.5, 1.0);
oTF->AddPoint(hid, alpha, 0.5, 1.0);
cTF->AddRGBPoint(hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
cTF->AddRGBPoint(hid, red, green, blue, 0.5, 1.0);
}
else if (next_hid == hid + 1 && starting)
continue;
else if (next_hid > hid + 1 && starting)
{
starting = false;
oTF->AddPoint(hid, alpha, 0.5, 1.0);
oTF->AddPoint(hid + 0.3, backAlpha, 0.5, 1.0);
cTF->AddRGBPoint(hid, red, green, blue, 0.5, 1.0);
cTF->AddRGBPoint(hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
}
}
if ( hid < m_objectTable->GetNumberOfRows() )
{
oTF->AddPoint(m_objectTable->GetNumberOfRows() + 0.3, backAlpha, 0.5, 1.0);
cTF->AddRGBPoint(m_objectTable->GetNumberOfRows() + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0);
}
}
updateRenderer();
}
void iA3DLabelledVolumeVis::renderSelection( std::vector<size_t> const & sortedSelInds, int classID, QColor const & classColor, QStandardItem* activeClassItem )
{
QColor BackColor(128, 128, 128, 0);
double backRGB[3];
backRGB[0] = BackColor.redF(); backRGB[1] = BackColor.greenF(); backRGB[2] = BackColor.blueF(); // background color
double red = 0.0, green = 0.0, blue = 0.0, alpha = 0.5, backAlpha = 0.00, classRGB[3], selRGB[3];
selRGB[0] = SelectedColor.redF();
selRGB[1] = SelectedColor.greenF();
selRGB[2] = SelectedColor.blueF();
classRGB[0] = classColor.redF();
classRGB[1] = classColor.greenF();
classRGB[2] = classColor.blueF();
// clear existing points
oTF->RemoveAllPoints();
cTF->RemoveAllPoints();
oTF->ClampingOff();
cTF->ClampingOff();
oTF->AddPoint( 0, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( 0, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
int hid = 0, next_hid = 1, prev_hid = -1, selectionIndex = 0, previous_selectionIndex = 0;
bool starting = false, hid_isASelection = false, previous_hid_isASelection = false;
int countClass = activeClassItem->rowCount();
int countSelection = sortedSelInds.size();
for ( size_t j = 0; j < countClass; ++j )
{
hid = activeClassItem->child( j )->text().toInt();
if ( countSelection > 0 )
{
if (hid-1 == sortedSelInds[selectionIndex] )
{
hid_isASelection = true;
red = SelectedColor.redF(), green = SelectedColor.greenF(), blue = SelectedColor.blueF();
if ( selectionIndex + 1 < sortedSelInds.size() )
selectionIndex++;
}
else
{
hid_isASelection = false;
red = classRGB[0]; green = classRGB[1]; blue = classRGB[2];
}
if ( prev_hid > 0 )
{
if (prev_hid-1 == sortedSelInds[previous_selectionIndex])
{
previous_hid_isASelection = true;
if ( previous_selectionIndex + 1 < sortedSelInds.size())
previous_selectionIndex++;
}
else
previous_hid_isASelection = false;
}
}
else
{
red = classRGB[0]; green = classRGB[1]; blue = classRGB[2];
}
// If we are not yet at the last object (of the class) get the next hid
if ( ( j + 1 ) < countClass )
{
next_hid = activeClassItem->child( j + 1 )->text().toInt();
}
else // If hid = the last object (of the class) we have to set the last object points
{
if ( starting ) // If we are in a sequence we have to set the ending (\)
{
oTF->AddPoint( hid - 1 + 0.3, alpha, 0.5, 1.0 );
oTF->AddPoint( hid - 0.5, alpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
if ( hid_isASelection )
{
cTF->AddRGBPoint( hid - 0.5, 1.0, 0.0, 0.0, 0.5, 1.0 );
cTF->AddRGBPoint( hid, 1.0, 0.0, 0.0, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
else
{
cTF->AddRGBPoint( hid - 0.5, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
if ( previous_hid_isASelection )
cTF->AddRGBPoint( hid - 1 + 0.3, 1.0, 0.0, 0.0, 0.5, 1.0 );
else
cTF->AddRGBPoint( hid - 1 + 0.3, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
break;
}
else // if we are not in a sequence we have to create the last tooth (/\)
{
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
break;
}
}
if ( next_hid > hid + 1 && !starting ) //Create one single tooth
{
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
else if ( next_hid == hid + 1 && !starting ) //Creates the beginning of a sequence (/)
{
starting = true;
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
}
else if ( next_hid == hid + 1 && starting ) //Continues the started sequence (-)
{
if ( !hid_isASelection && previous_hid_isASelection )
{
cTF->AddRGBPoint( hid - 1 + 0.3, selRGB[0], selRGB[1], selRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
oTF->AddPoint( hid - 1 + 0.3, alpha, 0.5, 1.0 );
oTF->AddPoint( hid - 0.5, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, alpha, 0.5, 1.0 );
}
else if ( hid_isASelection && !previous_hid_isASelection )
{
cTF->AddRGBPoint( hid - 0.5, selRGB[0], selRGB[1], selRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, selRGB[0], selRGB[1], selRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid - 1 + 0.3, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
oTF->AddPoint( hid - 0.5, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, alpha, 0.5, 1.0 );
oTF->AddPoint( hid - 1 + 0.3, alpha, 0.5, 1.0 );
}
}
else if ( next_hid > hid + 1 && starting ) // (\)
{
starting = false;
oTF->AddPoint( hid - 1 + 0.3, alpha, 0.5, 1.0 );
oTF->AddPoint( hid - 0.5, alpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
if ( previous_hid_isASelection )
cTF->AddRGBPoint( hid - 1 + 0.3, selRGB[0], selRGB[1], selRGB[2], 0.5, 1.0 );
else
cTF->AddRGBPoint( hid - 1 + 0.3, classRGB[0], classRGB[1], classRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
prev_hid = hid;
}
if ( hid < m_objectTable->GetNumberOfRows() ) // Creates the very last points (for all objects) if it's not created yet
{
oTF->AddPoint( m_objectTable->GetNumberOfRows() + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( m_objectTable->GetNumberOfRows() + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
updateRenderer();
}
void iA3DLabelledVolumeVis::renderLengthDistribution( vtkColorTransferFunction* ctFun, vtkFloatArray* extents, double halfInc, int filterID, double const * range )
{
// clear existing points
oTF->RemoveAllPoints();
cTF->RemoveAllPoints();
cTF->AddRGBPoint(0, 0.0, 0.0, 0.0);
for ( size_t objID = 0; objID < m_objectTable->GetNumberOfRows(); ++objID )
{
double ll = m_objectTable->GetValue(objID, m_columnMapping->value(iACsvConfig::Length)).ToDouble();
QColor color = getLengthColor( ctFun, objID );
if ( filterID == iAFeatureScoutObjectType::Fibers )
{
if ( ll >= range[0] && ll < extents->GetValue( 0 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 1.0 );
}
else if ( ll >= extents->GetValue( 0 ) + halfInc && ll < extents->GetValue( 1 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.03 );
}
else if ( ll >= extents->GetValue( 1 ) + halfInc && ll < extents->GetValue( 2 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.03 );
}
else if ( ll >= extents->GetValue( 2 ) + halfInc && ll < extents->GetValue( 5 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.015 );
}
else if ( ll >= extents->GetValue( 5 ) + halfInc && ll <= extents->GetValue( 7 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 1.0 );
}
}
else
{
if ( ll >= range[0] && ll < extents->GetValue( 0 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.5 );
}
else if ( ll >= extents->GetValue( 0 ) + halfInc && ll < extents->GetValue( 1 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.5 );
}
else if ( ll >= extents->GetValue( 5 ) + halfInc && ll <= extents->GetValue( 2 ) + halfInc )
{
oTF->AddPoint( objID + 1 - 0.5, 0.0 );
oTF->AddPoint( objID + 1 + 0.3, 0.0 );
oTF->AddPoint( objID + 1, 0.5 );
}
}
cTF->AddRGBPoint( objID + 1, color.redF(), color.greenF(), color.blueF() );
cTF->AddRGBPoint( objID + 1 - 0.5, color.redF(), color.greenF(), color.blueF() );
cTF->AddRGBPoint( objID + 1 + 0.3, color.redF(), color.greenF(), color.blueF() );
}
updateRenderer();
}
void ImageLoader::updateFromElement()
{
// If we're not making renderers for the page, then don't load images. We don't want to slow
// down the raw HTML parsing case by loading images we don't intend to display.
Document* document = m_element->document();
if (!document->renderer())
return;
AtomicString attr = m_element->imageSourceURL();
if (attr == m_failedLoadURL)
return;
// Do not load any image if the 'src' attribute is missing or if it is
// an empty string.
CachedResourceHandle<CachedImage> newImage = 0;
if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
CachedResourceRequest request(ResourceRequest(document->completeURL(sourceURI(attr))));
request.setInitiator(element());
String crossOriginMode = m_element->fastGetAttribute(HTMLNames::crossoriginAttr);
if (!crossOriginMode.isNull()) {
StoredCredentials allowCredentials = equalIgnoringCase(crossOriginMode, "use-credentials") ? AllowStoredCredentials : DoNotAllowStoredCredentials;
updateRequestForAccessControl(request.mutableResourceRequest(), document->securityOrigin(), allowCredentials);
}
if (m_loadManually) {
bool autoLoadOtherImages = document->cachedResourceLoader()->autoLoadImages();
document->cachedResourceLoader()->setAutoLoadImages(false);
newImage = new CachedImage(request.resourceRequest());
newImage->setLoading(true);
newImage->setOwningCachedResourceLoader(document->cachedResourceLoader());
document->cachedResourceLoader()->m_documentResources.set(newImage->url(), newImage.get());
document->cachedResourceLoader()->setAutoLoadImages(autoLoadOtherImages);
} else
newImage = document->cachedResourceLoader()->requestImage(request);
// If we do not have an image here, it means that a cross-site
// violation occurred, or that the image was blocked via Content
// Security Policy, or the page is being dismissed. Trigger an
// error event if the page is not being dismissed.
if (!newImage && !pageIsBeingDismissed(document)) {
m_failedLoadURL = attr;
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(this);
} else
clearFailedLoadURL();
} else if (!attr.isNull()) {
// Fire an error event if the url is empty.
// FIXME: Should we fire this event asynchronoulsy via errorEventSender()?
m_element->dispatchEvent(Event::create(eventNames().errorEvent, false, false));
}
CachedImage* oldImage = m_image.get();
if (newImage != oldImage) {
if (m_hasPendingBeforeLoadEvent) {
beforeLoadEventSender().cancelEvent(this);
m_hasPendingBeforeLoadEvent = false;
}
if (m_hasPendingLoadEvent) {
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
}
// Cancel error events that belong to the previous load, which is now cancelled by changing the src attribute.
// If newImage is null and m_hasPendingErrorEvent is true, we know the error event has been just posted by
// this load and we should not cancel the event.
// FIXME: If both previous load and this one got blocked with an error, we can receive one error event instead of two.
if (m_hasPendingErrorEvent && newImage) {
errorEventSender().cancelEvent(this);
m_hasPendingErrorEvent = false;
}
m_image = newImage;
m_hasPendingBeforeLoadEvent = !m_element->document()->isImageDocument() && newImage;
m_hasPendingLoadEvent = newImage;
m_imageComplete = !newImage;
if (newImage) {
if (!m_element->document()->isImageDocument()) {
if (!m_element->document()->hasListenerType(Document::BEFORELOAD_LISTENER))
dispatchPendingBeforeLoadEvent();
else
beforeLoadEventSender().dispatchEventSoon(this);
} else
updateRenderer();
// If newImage is cached, addClient() will result in the load event
// being queued to fire. Ensure this happens after beforeload is
// dispatched.
newImage->addClient(this);
}
if (oldImage)
oldImage->removeClient(this);
}
if (RenderImageResource* imageResource = renderImageResource())
imageResource->resetAnimation();
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
}
void ImageLoader::doUpdateFromElement(UpdateFromElementBehavior updateBehavior)
{
// FIXME: According to
// http://www.whatwg.org/specs/web-apps/current-work/multipage/embedded-content.html#the-img-element:the-img-element-55
// When "update image" is called due to environment changes and the load fails, onerror should not be called.
// That is currently not the case.
//
// We don't need to call clearLoader here: Either we were called from the
// task, or our caller updateFromElement cleared the task's loader (and set
// m_pendingTask to null).
m_pendingTask.clear();
// Make sure to only decrement the count when we exit this function
OwnPtr<IncrementLoadEventDelayCount> loadDelayCounter;
loadDelayCounter.swap(m_loadDelayCounter);
Document& document = m_element->document();
if (!document.isActive())
return;
AtomicString imageSourceURL = m_element->imageSourceURL();
KURL url = imageSourceToKURL(imageSourceURL);
ResourcePtr<ImageResource> newImage = 0;
if (!url.isNull()) {
// Unlike raw <img>, we block mixed content inside of <picture> or <img srcset>.
ResourceLoaderOptions resourceLoaderOptions = ResourceFetcher::defaultResourceOptions();
ResourceRequest resourceRequest(url);
FetchRequest request(ResourceRequest(url), element()->localName(), resourceLoaderOptions);
newImage = document.fetcher()->fetchImage(request);
if (!newImage && !pageIsBeingDismissed(&document))
crossSiteOrCSPViolationOccured(imageSourceURL);
else
clearFailedLoadURL();
} else if (!imageSourceURL.isNull()) {
// Fire an error event if the url string is not empty, but the KURL is.
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(this);
}
ImageResource* oldImage = m_image.get();
if (newImage != oldImage) {
sourceImageChanged();
if (m_hasPendingLoadEvent) {
loadEventSender().cancelEvent(this);
m_hasPendingLoadEvent = false;
}
// Cancel error events that belong to the previous load, which is now cancelled by changing the src attribute.
// If newImage is null and m_hasPendingErrorEvent is true, we know the error event has been just posted by
// this load and we should not cancel the event.
// FIXME: If both previous load and this one got blocked with an error, we can receive one error event instead of two.
if (m_hasPendingErrorEvent && newImage) {
errorEventSender().cancelEvent(this);
m_hasPendingErrorEvent = false;
}
m_image = newImage;
m_hasPendingLoadEvent = newImage;
m_imageComplete = !newImage;
updateRenderer();
// If newImage exists and is cached, addClient() will result in the load event
// being queued to fire. Ensure this happens after beforeload is dispatched.
if (newImage)
newImage->addClient(this);
if (oldImage)
oldImage->removeClient(this);
} else if (updateBehavior == UpdateSizeChanged && m_element->renderer() && m_element->renderer()->isImage()) {
toRenderImage(m_element->renderer())->intrinsicSizeChanged();
}
if (RenderImageResource* imageResource = renderImageResource())
imageResource->resetAnimation();
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
}
int main(int argc, char* argv[])
{
log_data = new Log(); // ugh
SDL_Window* window = 0;
SDL_GLContext gl = 0;
int win_w;
int win_h;
if(initGL(&window, &gl, &win_w, &win_h) == 1) return 1;
GLuint gl_depth_buff_id;
GLuint gl_framebuffer_id;
blit_renderer br; initBlitRenderer(&br);
renderer r; initRenderer(&r);
glGenRenderbuffers(1, &gl_depth_buff_id);
glBindRenderbuffer(GL_RENDERBUFFER, gl_depth_buff_id);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, br.texture_width, br.texture_height);
glGenFramebuffers(1, &gl_framebuffer_id);
glBindFramebuffer(GL_FRAMEBUFFER, gl_framebuffer_id);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, br.gl_texture_buff_id, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, gl_depth_buff_id);
Uint8 done = 0;
SDL_Event event;
while(!done)
{
while(SDL_PollEvent(&event))
{
if(
false
|| event.type == SDL_QUIT
|| event.type == SDL_KEYDOWN
#if DO_PLATFORM == DO_PLATFORM_ANDROID
|| event.type == SDL_FINGERDOWN
#endif
)
{
done = 1;
}
}
updateRenderer(&r);
//draw into FB
glBindFramebuffer(GL_FRAMEBUFFER, gl_framebuffer_id);
renderRenderer(&r,br.texture_width,br.texture_height);
//blit FB
glBindFramebuffer(GL_FRAMEBUFFER, 0);
renderBlitRenderer(&br,win_w,win_h);
SDL_GL_SwapWindow(window);
SDL_Delay(10);
}
SDL_GL_DeleteContext(gl);
IMG_Quit();
SDL_Quit();
exit(0);
return 0;
}
void iA3DLabelledVolumeVis::renderSingle( int labelID, int classID, QColor const & classColor, QStandardItem* activeClassItem )
{
int itemL = activeClassItem->rowCount();
double red = classColor.redF(),
green = classColor.greenF(),
blue = classColor.blueF(),
alpha = 0.5,
backAlpha = 0.0,
backRGB[3] = { 0.0, 0.0, 0.0 };
// clear existing points
oTF->RemoveAllPoints();
cTF->RemoveAllPoints();
// set background opacity and color with clamping off
oTF->ClampingOff();
cTF->ClampingOff();
oTF->AddPoint(0, backAlpha);
cTF->AddRGBPoint(0, backRGB[0], backRGB[1], backRGB[2]);
if ( labelID > 0 ) // for single object selection
{
if ( (labelID - 1) >= 0)
{
oTF->AddPoint(labelID - 0.5, backAlpha);
oTF->AddPoint(labelID - 0.49, alpha);
cTF->AddRGBPoint(labelID - 0.5, backRGB[0], backRGB[1], backRGB[2]);
cTF->AddRGBPoint(labelID - 0.49, red, green, blue);
}
oTF->AddPoint(labelID, alpha);
cTF->AddRGBPoint(labelID, red, green, blue);
if ((labelID + 1) <= m_objectTable->GetNumberOfRows())
{
oTF->AddPoint(labelID + 0.3, backAlpha);
oTF->AddPoint(labelID + 0.29, alpha);
cTF->AddRGBPoint(labelID + 0.3, backRGB[0], backRGB[1], backRGB[2]);
cTF->AddRGBPoint(labelID + 0.29, red, green, blue);
}
}
else // for single class selection
{
int hid = 0, next_hid = 1;
bool starting = false;
for ( int j = 0; j < itemL; ++j )
{
hid = activeClassItem->child( j, 0 )->text().toInt();
if ( j + 1 < itemL )
next_hid = activeClassItem->child( j + 1, 0 )->text().toInt();
else
{
if ( starting )
{
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
break;
}
else
{
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
break;
}
}
//Create one single tooth
if ( next_hid > hid + 1 && !starting )
{
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
else if ( next_hid == hid + 1 && !starting )
{
starting = true;
oTF->AddPoint( hid - 0.5, backAlpha, 0.5, 1.0 );
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid - 0.5, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
}
else if ( next_hid == hid + 1 && starting )
continue;
else if ( next_hid > hid + 1 && starting )
{
starting = false;
oTF->AddPoint( hid, alpha, 0.5, 1.0 );
oTF->AddPoint( hid + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( hid, red, green, blue, 0.5, 1.0 );
cTF->AddRGBPoint( hid + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
}
if ( hid < m_objectTable->GetNumberOfRows() )
{
oTF->AddPoint( m_objectTable->GetNumberOfRows() + 0.3, backAlpha, 0.5, 1.0 );
cTF->AddRGBPoint( m_objectTable->GetNumberOfRows() + 0.3, backRGB[0], backRGB[1], backRGB[2], 0.5, 1.0 );
}
}
updateRenderer();
}
void iA3DColoredPolyObjectVis::hideBoundingBox()
{
m_widget->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->RemoveActor(m_outlineActor);
updateRenderer();
}
void iA3DColoredPolyObjectVis::showBoundingBox()
{
m_outlineMapper->Update();
m_widget->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->AddActor(m_outlineActor);
updateRenderer();
}
void iA3DColoredPolyObjectVis::updatePolyMapper()
{
m_colors->Modified();
m_mapper->Update();
updateRenderer();
}
//--------------------------------------------------------------
void testApp::update(){
for(int i = 0; i < comps.size(); i++){
comps[i]->load->enabled = viewComps || !allLoaded;
comps[i]->toggle->enabled = viewComps || !allLoaded;
}
if(shouldResetDuration){
timeline.setDurationInFrames(currentDuration);
shouldResetDuration = false;
}
if(!allLoaded) return;
if(currentLockCamera != cameraTrack.lockCameraToTrack){
if(!currentLockCamera){
cam.targetNode.setPosition(cam.getPosition());
cam.targetNode.setOrientation(cam.getOrientationQuat());
cam.rotationX = cam.targetXRot = -cam.getHeading();
cam.rotationY = cam.targetYRot = -cam.getPitch();
cam.rotationZ = -cam.getRoll();
}
cameraTrack.lockCameraToTrack = currentLockCamera;
}
if(cameraTrack.lockCameraToTrack){
cameraTrack.setTimelineInOutToTrack();
}
else{
timeline.setInOutRange(ofRange(0,1));
}
cam.applyRotation = !cameraTrack.lockCameraToTrack;
cam.applyTranslation = !cameraTrack.lockCameraToTrack;
if(enableVideoInOut){
videoTimelineElement.setInFrame(videoInPercent*lowResPlayer->getTotalNumFrames());
videoTimelineElement.setOutFrame(videoOutPercent*lowResPlayer->getTotalNumFrames());
}
else{
videoTimelineElement.setInFrame(0);
videoTimelineElement.setOutFrame(lowResPlayer->getTotalNumFrames());
}
if(startRenderMode && !hasHiresVideo){
ofSystemAlertDialog("This composition doesn't have a hi res movie so we can't render!");
startRenderMode = false;
}
if(startRenderMode){
viewComps = false;
saveComposition();
for(int i = 0; i < comps.size(); i++){
if(comps[i]->batchExport){
loadCompositionAtIndex(i);
break;
}
}
startRenderMode = false;
currentlyRendering = true;
saveFolder = currentCompositionDirectory + "rendered"+pathDelim;
ofDirectory outputDirectory(saveFolder);
if(!outputDirectory.exists()) outputDirectory.create(true);
hiResPlayer->play();
hiResPlayer->setSpeed(0);
hiResPlayer->setVolume(0);
renderer.setRGBTexture(*hiResPlayer);
renderer.setTextureScale(1.0, 1.0);
// currentSimplify = 1;
lastRenderFrame = currentRenderFrame-1;
numFramesToRender = timeline.getOutFrame() - timeline.getInFrame();
numFramesRendered = 0;
currentLockCamera = cameraTrack.lockCameraToTrack = true;
cameraTrack.setTimelineInOutToTrack();
currentRenderFrame = timeline.getInFrame();
}
if(currentlyRendering){
//hiResPlayer->setFrame(currentRenderFrame % hiResPlayer->getTotalNumFrames());
timeline.setCurrentFrame(currentRenderFrame);
videoTimelineElement.selectFrame(currentRenderFrame);
hiResPlayer->setFrame(videoTimelineElement.selectFrame(currentRenderFrame));
hiResPlayer->update();
// cout << "would have set hi res frame to " << currentRenderFrame % hiResPlayer->getTotalNumFrames() << endl;
// cout << "instead set it to " << hiResPlayer->getCurrentFrame() << endl;
////////
// char filename[512];
// sprintf(filename, "%s/TEST_FRAME_%05d_%05d_A.png", saveFolder.c_str(), currentRenderFrame, hiResPlayer->getCurrentFrame());
// savingImage.saveImage(filename);
// savingImage.setFromPixels(hiResPlayer->getPixelsRef());
// savingImage.saveImage(filename);
//
// cout << "FRAME UPDATE" << endl;
// cout << " setting frame to " << currentRenderFrame << " actual frame is " << hiResPlayer->getCurrentFrame() << endl;
// cout << " set to percent " << 1.0*currentRenderFrame/hiResPlayer->getTotalNumFrames() << " actual percent " << hiResPlayer->getPosition() << endl;
////////
updateRenderer(*hiResPlayer);
}
if(!currentlyRendering){
lowResPlayer->update();
if(!temporalAlignmentMode && lowResPlayer->isFrameNew()){
updateRenderer(*lowResPlayer);
}
if(temporalAlignmentMode && currentDepthFrame != depthSequence.getSelectedFrame()){
updateRenderer(*lowResPlayer);
}
if(sampleCamera){
cameraTrack.sample();
}
if(captureFramePair && temporalAlignmentMode){
alignmentScrubber.registerCurrentAlignment();
alignmentScrubber.save();
captureFramePair = false;
}
}
if(shouldClearCameraMoves){
cameraTrack.getCameraTrack().reset();
shouldClearCameraMoves = false;
}
if(shouldSaveCameraPoint){
//cameraRecorder.sample(lowResPlayer->getCurrentFrame());
cameraTrack.getCameraTrack().sample(timeline.getCurrentFrame());
shouldSaveCameraPoint = false;
}
if(shouldResetCamera){
cam.targetNode.setPosition(ofVec3f());
cam.targetNode.setOrientation(ofQuaternion());
cam.targetXRot = -180;
cam.targetYRot = 0;
cam.rotationZ = 0;
shouldResetCamera = false;
}
// newCompButton->enabled = viewComps;
// saveCompButton->enabled = viewComps;
if(currentXAdditiveShift != renderer.yshift ||
currentYAdditiveShift != renderer.yshift ||
currentXMultiplyShift != renderer.xmult ||
currentYMultiplyShift != renderer.ymult ||
currentXScale != renderer.xscale ||
currentYScale != renderer.yscale ||
currentRotationCompensation != renderer.rotationCompensation ||
currentSimplify != renderer.getSimplification() ||
currentEdgeCull != renderer.edgeCull ||
farClip != renderer.farClip ||
currentMirror != renderer.mirror) {
renderer.xshift = currentXAdditiveShift;
renderer.yshift = currentYAdditiveShift;
renderer.xmult = currentXMultiplyShift;
renderer.ymult = currentYMultiplyShift;
renderer.xscale = currentXScale;
renderer.yscale = currentYScale;
renderer.edgeCull = currentEdgeCull;
renderer.setSimplification(currentSimplify);
renderer.farClip = farClip;
renderer.mirror = currentMirror;
renderer.update();
}
//update shaders
renderer.fadeToWhite = timeline.getKeyframeValue("White");
if(!temporalAlignmentMode && !currentlyRendering && lowResPlayer->getSpeed() == 0.0){
videoTimelineElement.selectFrame(timeline.getCurrentFrame());
}
}
