自学教程：C++ updateRenderer函数代码示例

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(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 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);}

//.........这里部分代码省略.........	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();}

//.........这里部分代码省略.........				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//.........这里部分代码省略.........

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 iA3DColoredPolyObjectVis::hideBoundingBox(){	m_widget->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->RemoveActor(m_outlineActor);	updateRenderer();}

//.........这里部分代码省略.........		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;