//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicRangeFilterInsertExec::redo()
{
RimCellRangeFilter* rangeFilter = createRangeFilter();
if (rangeFilter)
{
size_t index = m_cellRangeFilterCollection->rangeFilters.index(m_cellRangeFilter);
CVF_ASSERT(index < m_cellRangeFilterCollection->rangeFilters.size());
m_cellRangeFilterCollection->rangeFilters.insertAt(static_cast<int>(index), rangeFilter);
rangeFilter->setDefaultValues();
applyCommandDataOnFilter(rangeFilter);
m_cellRangeFilterCollection->updateDisplayModeNotifyManagedViews(NULL);
m_cellRangeFilterCollection->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(rangeFilter);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicSummaryCurveCreator::copyEnsembleCurveAndAddToCurveSet(const RimSummaryCurve* curve,
RimEnsembleCurveSet* curveSet,
bool forceVisible)
{
RimSummaryCurve* curveCopy =
dynamic_cast<RimSummaryCurve*>(curve->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(curveCopy);
if (forceVisible)
{
curveCopy->setCurveVisiblity(true);
}
curveSet->addCurve(curveCopy);
// The curve creator is not a descendant of the project, and need to be set manually
curveCopy->setSummaryCaseY(curve->summaryCaseY());
curveCopy->initAfterReadRecursively();
curveCopy->loadDataAndUpdate(false);
}
double EarClipTesselator::calculateProjectedPolygonArea() const
{
CVF_ASSERT(m_X > -1 && m_Y > -1);
double A = 0;
std::list<size_t>::const_iterator p = m_polygonIndices.end();
--p;
std::list<size_t>::const_iterator q = m_polygonIndices.begin();
while (q != m_polygonIndices.end())
{
A += (*m_nodeCoords)[*p][m_X] * (*m_nodeCoords)[*q][m_Y] - (*m_nodeCoords)[*q][m_X]*(*m_nodeCoords)[*p][m_Y];
p = q;
++q;
}
return A*0.5;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PerformanceInfo::update(const PerformanceInfo& perf)
{
totalDrawTime += perf.totalDrawTime;
computeVisiblePartsTime += perf.computeVisiblePartsTime;
buildRenderQueueTime += perf.buildRenderQueueTime;
sortRenderQueueTime += perf.sortRenderQueueTime;
renderEngineTime += perf.renderEngineTime;
visiblePartsCount += perf.visiblePartsCount;
renderedPartsCount += perf.renderedPartsCount;
vertexCount += perf.vertexCount;
triangleCount += perf.triangleCount;
openGLPrimitiveCount += perf.openGLPrimitiveCount;
applyRenderStateCount += perf.applyRenderStateCount;
shaderProgramChangesCount += perf.shaderProgramChangesCount;
CVF_ASSERT(m_nextHistoryItem >= 0 && m_nextHistoryItem < NUM_PERFORMANCE_HISTORY_ITEMS);
m_totalDrawTimeHistory[m_nextHistoryItem] = totalDrawTime;
m_nextHistoryItem++;
if (m_nextHistoryItem >= NUM_PERFORMANCE_HISTORY_ITEMS) m_nextHistoryItem = 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
const QVariant& oldValue,
const QVariant& newValue)
{
if (changedField == &m_isActive)
{
RimGridView* rimView = nullptr;
this->firstAncestorOrThisOfType(rimView);
CVF_ASSERT(rimView);
if (rimView) rimView->showGridCells(m_isActive);
updateUiIconFromState(m_isActive);
}
RimGridView* rimView = nullptr;
this->firstAncestorOrThisOfType(rimView);
rimView->scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Variant PropertyXmlSerializer::arrayVariantFromXmlElement(const XmlElement& xmlArrayVariantElement)
{
CVF_ASSERT(xmlArrayVariantElement.name().toLower() == "array");
std::vector<Variant> arr;
const XmlElement* xmlElem = xmlArrayVariantElement.firstChildElement();
while (xmlElem)
{
Variant variant = variantFromXmlElement(*xmlElem);
if (variant.isValid())
{
arr.push_back(variant);
}
xmlElem = xmlElem->nextSiblingElement();
}
return Variant(arr);
}
bool EarClipTesselator::isTriangleValid( std::list<size_t>::const_iterator u, std::list<size_t>::const_iterator v, std::list<size_t>::const_iterator w) const
{
CVF_ASSERT(m_X > -1 && m_Y > -1);
cvf::Vec3d A = (*m_nodeCoords)[*u];
cvf::Vec3d B = (*m_nodeCoords)[*v];
cvf::Vec3d C = (*m_nodeCoords)[*w];
if ( m_areaTolerance > (((B[m_X]-A[m_X])*(C[m_Y]-A[m_Y])) - ((B[m_Y]-A[m_Y])*(C[m_X]-A[m_X]))) ) return false;
std::list<size_t>::const_iterator c;
std::list<size_t>::const_iterator outside;
for (c = m_polygonIndices.begin(); c != m_polygonIndices.end(); ++c)
{
// The polygon points that actually make up the triangle candidate does not count
// (but the same points on different positions in the polygon does!
// Except those one off the triangle, that references the start or end of the triangle)
if ( (c == u) || (c == v) || (c == w)) continue;
// Originally the below tests was not included which resulted in missing triangles sometimes
outside = w; ++outside; if (outside == m_polygonIndices.end()) outside = m_polygonIndices.begin();
if (c == outside && *c == *u)
{
continue;
}
outside = u; if (outside == m_polygonIndices.begin()) outside = m_polygonIndices.end(); --outside;
if (c == outside && *c == *w)
{
continue;
}
cvf::Vec3d P = (*m_nodeCoords)[*c];
if (isPointInsideTriangle(A, B, C, P)) return false;
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaSocketServer::slotReadyRead()
{
switch (m_readState)
{
case ReadingCommand :
{
readCommandFromOctave();
break;
}
case ReadingPropertyData :
{
readPropertyDataFromOctave();
break;
}
default:
CVF_ASSERT(false);
break;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CategoryMapper::recomputeMaxTexCoord()
{
const uint numColors = static_cast<uint>(m_colors.size());
if (numColors == 0)
{
m_maxTexCoord = 1.0;
return;
}
const uint numPixelsPerColor = m_textureSize / numColors;
if (numPixelsPerColor == 0)
{
m_maxTexCoord = 1.0;
return;
}
uint texturePixelsInUse = numColors*numPixelsPerColor;
CVF_ASSERT(texturePixelsInUse <= m_textureSize);
m_maxTexCoord = static_cast<double>(texturePixelsInUse) / static_cast<double>(m_textureSize);
}
//--------------------------------------------------------------------------------------------------
/// Update the bounding box of this node (recursive)
//--------------------------------------------------------------------------------------------------
void ModelBasicTreeNode::updateBoundingBoxesRecursive()
{
m_boundingBox.reset();
uint numChildren = childCount();
uint i;
for (i = 0; i < numChildren; i++)
{
ModelBasicTreeNode* c = child(i);
CVF_ASSERT(c);
c->updateBoundingBoxesRecursive();
m_boundingBox.add(c->boundingBox());
}
if (m_partList.notNull())
{
m_partList->updateBoundingBoxesRecursive();
m_boundingBox.add(m_partList->boundingBox());
}
}
//--------------------------------------------------------------------------------------------------
/// Set or add a uniform to the UniformSet
///
/// If a uniform with the same name as the incoming uniform is already present in the set,
/// the existing uniform will be replaced.
//--------------------------------------------------------------------------------------------------
void UniformSet::setUniform(Uniform* uniform)
{
CVF_ASSERT(uniform);
// Check if uniform is already in the set
size_t numUniforms = m_uniforms.size();
for (size_t i = 0; i < numUniforms; ++i)
{
if (System::strcmp(m_uniforms[i]->name(), uniform->name()) == 0)
{
if (m_uniforms[i] != uniform)
{
m_uniforms[i] = uniform;
}
return;
}
}
m_uniforms.push_back(uniform);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector< RigFemResultAddress> RigFemPartResultsCollection::getResAddrToComponentsToRead(const RigFemResultAddress& resVarAddr)
{
std::map<std::string, std::vector<std::string> > fieldAndComponentNames;
switch (resVarAddr.resultPosType)
{
case RIG_NODAL:
fieldAndComponentNames = m_readerInterface->scalarNodeFieldAndComponentNames();
break;
case RIG_ELEMENT_NODAL:
fieldAndComponentNames = m_readerInterface->scalarElementNodeFieldAndComponentNames();
break;
case RIG_INTEGRATION_POINT:
fieldAndComponentNames = m_readerInterface->scalarIntegrationPointFieldAndComponentNames();
break;
}
std::vector< RigFemResultAddress> resAddressToComponents;
std::map<std::string, std::vector<std::string> >::iterator fcIt = fieldAndComponentNames.find(resVarAddr.fieldName);
if (fcIt != fieldAndComponentNames.end())
{
std::vector<std::string> compNames = fcIt->second;
if (resVarAddr.componentName != "") // If we did not request a particular component, do not add the components
{
for (size_t cIdx = 0; cIdx < compNames.size(); ++cIdx)
{
resAddressToComponents.push_back(RigFemResultAddress(resVarAddr.resultPosType, resVarAddr.fieldName, compNames[cIdx]));
}
}
if (compNames.size() == 0) // This is a scalar field. Add one component named ""
{
CVF_ASSERT(resVarAddr.componentName == "");
resAddressToComponents.push_back(resVarAddr);
}
}
return resAddressToComponents;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPasteEclipseViewsFeature::onActionTriggered(bool isChecked)
{
PdmObjectHandle* destinationObject = dynamic_cast<PdmObjectHandle*>(SelectionManager::instance()->selectedItem());
RimEclipseCase* eclipseCase = RicPasteFeatureImpl::findEclipseCase(destinationObject);
assert(eclipseCase);
PdmObjectGroup objectGroup;
RicPasteFeatureImpl::findObjectsFromClipboardRefs(&objectGroup);
if (objectGroup.objects.size() == 0) return;
std::vector<caf::PdmPointer<RimEclipseView> > eclipseViews;
objectGroup.objectsByType(&eclipseViews);
// Add cases to case group
for (size_t i = 0; i < eclipseViews.size(); i++)
{
RimEclipseView* rimReservoirView = dynamic_cast<RimEclipseView*>(eclipseViews[i]->xmlCapability()->copyByXmlSerialization(PdmDefaultObjectFactory::instance()));
CVF_ASSERT(rimReservoirView);
QString nameOfCopy = QString("Copy of ") + rimReservoirView->name;
rimReservoirView->name = nameOfCopy;
eclipseCase->reservoirViews().push_back(rimReservoirView);
rimReservoirView->setEclipseCase(eclipseCase);
// Resolve references after reservoir view has been inserted into Rim structures
// Intersections referencing a well path/ simulation well requires this
// TODO: initAfterReadRecursively can probably be removed
rimReservoirView->initAfterReadRecursively();
rimReservoirView->resolveReferencesRecursively();
rimReservoirView->loadDataAndUpdate();
caf::PdmDocument::updateUiIconStateRecursively(rimReservoirView);
eclipseCase->updateConnectedEditors();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RigFault* RigMainGrid::findFaultFromCellIndexAndCellFace(size_t reservoirCellIndex, cvf::StructGridInterface::FaceType face) const
{
CVF_ASSERT(m_faultsPrCellAcc.notNull());
if (face == cvf::StructGridInterface::NO_FACE) return NULL;
int faultIdx = m_faultsPrCellAcc->faultIdx(reservoirCellIndex, face);
if (faultIdx != RigFaultsPrCellAccumulator::NO_FAULT )
{
return m_faults.at(faultIdx);
}
#if 0
for (size_t i = 0; i < m_faults.size(); i++)
{
const RigFault* rigFault = m_faults.at(i);
const std::vector<RigFault::FaultFace>& faultFaces = rigFault->faultFaces();
for (size_t fIdx = 0; fIdx < faultFaces.size(); fIdx++)
{
if (faultFaces[fIdx].m_nativeReservoirCellIndex == cellIndex)
{
if (face == faultFaces[fIdx].m_nativeFace )
{
return rigFault;
}
}
if (faultFaces[fIdx].m_oppositeReservoirCellIndex == cellIndex)
{
if (face == cvf::StructGridInterface::oppositeFace(faultFaces[fIdx].m_nativeFace))
{
return rigFault;
}
}
}
}
#endif
return NULL;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGeoMechView::loadDataAndUpdate()
{
caf::ProgressInfo progress(7, "");
progress.setNextProgressIncrement(5);
updateScaleTransform();
if (m_geomechCase)
{
std::string errorMessage;
if (!m_geomechCase->openGeoMechCase(&errorMessage))
{
QString displayMessage = errorMessage.empty() ? "Could not open the Odb file: \n" + m_geomechCase->caseFileName() : QString::fromStdString(errorMessage);
QMessageBox::warning(RiuMainWindow::instance(),
"File open error",
displayMessage);
m_geomechCase = NULL;
return;
}
}
progress.incrementProgress();
progress.setProgressDescription("Reading Current Result");
CVF_ASSERT(this->cellResult() != NULL);
if (this->hasUserRequestedAnimation())
{
m_geomechCase->geoMechData()->femPartResults()->assertResultsLoaded(this->cellResult()->resultAddress());
}
progress.incrementProgress();
progress.setProgressDescription("Create Display model");
updateViewerWidget();
this->geoMechPropertyFilterCollection()->loadAndInitializePropertyFilters();
this->scheduleCreateDisplayModelAndRedraw();
progress.incrementProgress();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
float RigFemPart::characteristicElementSize()
{
if (m_characteristicElementSize != std::numeric_limits<float>::infinity()) return m_characteristicElementSize;
// take 100 elements
float elmIdxJump = elementCount() / 100.0f;
int elmIdxIncrement = elmIdxJump < 1 ? 1: (int) elmIdxJump;
int elmsToAverageCount = 0;
float sumMaxEdgeLength = 0;
for (int elmIdx = 0; elmIdx < elementCount(); elmIdx += elmIdxIncrement)
{
RigElementType eType = this->elementType(elmIdx);
if (eType == HEX8 || eType == HEX8P)
{
const int* elmentConn = this->connectivities(elmIdx);
cvf::Vec3f nodePos0 = this->nodes().coordinates[elmentConn[0]];
cvf::Vec3f nodePos1 = this->nodes().coordinates[elmentConn[1]];
cvf::Vec3f nodePos3 = this->nodes().coordinates[elmentConn[3]];
cvf::Vec3f nodePos4 = this->nodes().coordinates[elmentConn[4]];
float l1 = (nodePos1-nodePos0).length();
float l3 = (nodePos3-nodePos0).length();
float l4 = (nodePos4-nodePos0).length();
float maxLength = l1 > l3 ? l1: l3;
maxLength = maxLength > l4 ? maxLength: l4;
sumMaxEdgeLength += maxLength;
++elmsToAverageCount;
}
}
CVF_ASSERT(elmsToAverageCount);
m_characteristicElementSize = sumMaxEdgeLength/elmsToAverageCount;
return m_characteristicElementSize;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGeoMechView::RimGeoMechView(void)
{
RiaApplication* app = RiaApplication::instance();
RiaPreferences* preferences = app->preferences();
CVF_ASSERT(preferences);
CAF_PDM_InitObject("Geomechanical View", ":/ReservoirView.png", "", "");
CAF_PDM_InitFieldNoDefault(&cellResult, "GridCellResult", "Color Result", ":/CellResult.png", "", "");
cellResult = new RimGeoMechCellColors();
cellResult.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_propertyFilterCollection, "PropertyFilters", "Property Filters", "", "", "");
m_propertyFilterCollection = new RimGeoMechPropertyFilterCollection();
m_propertyFilterCollection.uiCapability()->setUiHidden(true);
//this->cellResult()->setReservoirView(this);
this->cellResult()->legendConfig()->setReservoirView(this);
m_scaleTransform = new cvf::Transform();
m_vizLogic = new RivGeoMechVizLogic(this);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimValveTemplate* RicNewValveTemplateFeature::createNewValveTemplate()
{
RimProject* project = RiaApplication::instance()->project();
CVF_ASSERT(project);
RimOilField* oilfield = project->activeOilField();
if (oilfield == nullptr) return nullptr;
RimValveTemplateCollection* valveTemplateColl = oilfield->valveTemplateCollection();
if (valveTemplateColl)
{
RimValveTemplate* valveTemplate = new RimValveTemplate();
QString userLabel = QString("Valve Template #%1").arg(valveTemplateColl->valveTemplates().size() + 1);
valveTemplate->setUserLabel(userLabel);
valveTemplateColl->addValveTemplate(valveTemplate);
valveTemplate->setUnitSystem(valveTemplateColl->defaultUnitSystemType());
valveTemplate->setDefaultValuesFromUnits();
return valveTemplate;
}
return nullptr;
}
//--------------------------------------------------------------------------------------------------
/// Reads the property data requested into the \a reservoir, overwriting any previous
/// properties with the same name.
//--------------------------------------------------------------------------------------------------
bool RifEclipseInputFileTools::readProperty(const QString& fileName, RigEclipseCaseData* caseData, const QString& eclipseKeyWord, const QString& resultName)
{
CVF_ASSERT(caseData);
if (!isValidDataKeyword(eclipseKeyWord)) return false;
FILE* filePointer = util_fopen(fileName.toLatin1().data(), "r");
if (!filePointer) return false;
ecl_kw_type* eclipseKeywordData = ecl_kw_fscanf_alloc_grdecl_dynamic__(filePointer, eclipseKeyWord.toLatin1().data(), false, ecl_type_create_from_type(ECL_FLOAT_TYPE));
bool isOk = false;
if (eclipseKeywordData)
{
isOk = readDataFromKeyword(eclipseKeywordData, caseData, resultName);
ecl_kw_free(eclipseKeywordData);
}
util_fclose(filePointer);
return isOk;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void LocatorPanWalkRotate::updatePan(double tx, double ty)
{
CVF_ASSERT(m_camera.notNull());
// Viewport size in world coordinates
const double aspect = m_camera->aspectRatio();
const double vpWorldSizeY = m_camera->frontPlaneFrustumHeight();
const double vpWorldSizeX = vpWorldSizeY*aspect;
const Vec3d camUp = m_camera->up();
const Vec3d camRight = m_camera->right();
Camera::ProjectionType projType = m_camera->projection();
if (projType == Camera::PERSPECTIVE)
{
// Compute distance from camera to point projected onto camera forward direction
const Vec3d camPos = m_camera->position();
const Vec3d camDir = m_camera->direction();
const Vec3d vDiff = m_pos - camPos;
const double camPointDist = Math::abs(camDir*vDiff);
const double nearPlane = m_camera->nearPlane();
Vec3d vX = camRight*((tx*vpWorldSizeX)/nearPlane)*camPointDist;
Vec3d vY = camUp*((ty*vpWorldSizeY)/nearPlane)*camPointDist;
Vec3d translation = vX + vY;
m_pos += translation;
}
else if (projType == Camera::ORTHO)
{
Vec3d vX = camRight*tx*vpWorldSizeX;
Vec3d vY = camUp*ty*vpWorldSizeY;
Vec3d translation = vX + vY;
m_pos += translation;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicCopyIntersectionsToAllViewsInCaseFeature::copyIntersectionBoxesToOtherViews(RimCase& gridCase, std::vector<RimIntersectionBox*> intersectionBoxes)
{
for (RimIntersectionBox* intersectionBox : intersectionBoxes)
{
for (Rim3dView* const view : gridCase.views())
{
RimGridView* currGridView = dynamic_cast<RimGridView*>(view);
RimGridView* parentView = nullptr;
intersectionBox->firstAncestorOrThisOfType(parentView);
if (currGridView && parentView != nullptr && parentView != currGridView)
{
RimIntersectionCollection* destCollection = currGridView->crossSectionCollection();
RimIntersectionBox* copy = dynamic_cast<RimIntersectionBox*>(intersectionBox->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(copy);
destCollection->appendIntersectionBoxAndUpdate(copy);
}
}
}
}
//--------------------------------------------------------------------------------------------------
/// Get set of Eclipse files based on an input file and its path
//--------------------------------------------------------------------------------------------------
bool RifEclipseOutputFileTools::findSiblingFilesWithSameBaseName(const QString& fullPathFileName, QStringList* baseNameFiles)
{
CVF_ASSERT(baseNameFiles);
baseNameFiles->clear();
QString filePath = QFileInfo(fullPathFileName).absoluteFilePath();
filePath = QFileInfo(filePath).path();
QString fileNameBase = QFileInfo(fullPathFileName).completeBaseName();
stringlist_type* eclipseFiles = stringlist_alloc_new();
ecl_util_select_filelist(RiaStringEncodingTools::toNativeEncoded(filePath).data(), RiaStringEncodingTools::toNativeEncoded(fileNameBase).data(), ECL_OTHER_FILE, false, eclipseFiles);
int i;
for (i = 0; i < stringlist_get_size(eclipseFiles); i++)
{
baseNameFiles->append(RiaStringEncodingTools::fromNativeEncoded(stringlist_safe_iget(eclipseFiles, i)));
}
stringlist_free(eclipseFiles);
return baseNameFiles->count() > 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCellRangeFilter::setDefaultValues()
{
CVF_ASSERT(m_parentContainer);
RigGridBase* grid = selectedGrid();
RigActiveCellInfo* actCellInfo = m_parentContainer->activeCellInfo();
if (grid == m_parentContainer->mainGrid() && actCellInfo)
{
cvf::Vec3st min, max;
actCellInfo->IJKBoundingBox(min, max);
// Adjust to Eclipse indexing
min.x() = min.x() + 1;
min.y() = min.y() + 1;
min.z() = min.z() + 1;
max.x() = max.x() + 1;
max.y() = max.y() + 1;
max.z() = max.z() + 1;
startIndexI = static_cast<int>(min.x());
startIndexJ = static_cast<int>(min.y());
startIndexK = static_cast<int>(min.z());
cellCountI = static_cast<int>(max.x() - min.x() + 1);
cellCountJ = static_cast<int>(max.y() - min.y() + 1);
cellCountK = static_cast<int>(max.z() - min.z() + 1);
}
else
{
startIndexI = 1;
startIndexJ = 1;
startIndexK = 1;
cellCountI = static_cast<int>(grid->cellCountI() );
cellCountJ = static_cast<int>(grid->cellCountJ() );
cellCountK = static_cast<int>(grid->cellCountK() );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPasteSummaryPlotFeature::copyPlotAndAddToCollection(RimSummaryPlot *sourcePlot)
{
RimSummaryPlotCollection* plotColl = caf::firstAncestorOfTypeFromSelectedObject<RimSummaryPlotCollection*>();
if (plotColl)
{
RimSummaryPlot* newSummaryPlot = dynamic_cast<RimSummaryPlot*>(sourcePlot->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(newSummaryPlot);
plotColl->summaryPlots.push_back(newSummaryPlot);
// Resolve references after object has been inserted into the data model
newSummaryPlot->resolveReferencesRecursively();
newSummaryPlot->initAfterReadRecursively();
QString nameOfCopy = QString("Copy of ") + newSummaryPlot->description();
newSummaryPlot->setDescription(nameOfCopy);
plotColl->updateConnectedEditors();
newSummaryPlot->loadDataAndUpdate();
}
}
//--------------------------------------------------------------------------------------------------
/// Add one face
///
/// The type of primitive added will be determined from the number of indices passed in \a indices
///
/// \remarks Currently, points and lines are not supported. Faces with more than 4 indices will
/// be triangulated using fanning
//--------------------------------------------------------------------------------------------------
void GeometryBuilder::addFace(const UIntArray& indices)
{
size_t numIndices = indices.size();
CVF_ASSERT(numIndices >= 3);
if (numIndices == 3)
{
addTriangle(indices[0], indices[1], indices[2]);
}
else if (numIndices == 4)
{
addQuad(indices[0], indices[1], indices[2], indices[3]);
}
else
{
size_t numTriangles = numIndices - 2;
size_t i;
for (i = 0; i < numTriangles; i++)
{
addTriangle(indices[0], indices[i + 1], indices[i + 2]);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivTernaryTextureCoordsCreator::createTextureCoords(cvf::Vec2fArray* textureCoords, const std::vector<size_t>& triangleToCellIdx, const RigTernaryResultAccessor* resultAccessor, const RivTernaryResultToTextureMapper* texMapper)
{
CVF_ASSERT(textureCoords && resultAccessor && texMapper);
size_t numVertices = triangleToCellIdx.size() * 3;
textureCoords->resize(numVertices);
cvf::Vec2f* rawPtr = textureCoords->ptr();
#pragma omp parallel for
for (int i = 0; i < static_cast<int>(triangleToCellIdx.size()); i++)
{
size_t cellIdx = triangleToCellIdx[i];
cvf::Vec2d resultValue = resultAccessor->cellScalarGlobIdx(cellIdx);
cvf::Vec2f texCoord = texMapper->getTexCoord(resultValue.x(), resultValue.y(), cellIdx);
size_t j;
for (j = 0; j < 3; j++)
{
rawPtr[i * 3 + j] = texCoord;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void CategoryMapper::setInterpolateColors(const cvf::Color3ubArray& colorArray)
{
CVF_ASSERT(colorArray.size());
if (m_categoryValues.size() > 1 && colorArray.size() > 1)
{
m_colors = *interpolateColorArray(colorArray, static_cast<cvf::uint>(m_categoryValues.size()));
recomputeMaxTexCoord();
return;
}
// Either we are requesting one output color, or we have only one input color
m_colors.clear();
m_colors.reserve(m_categoryValues.size());
for (size_t cIdx = 0; cIdx < m_categoryValues.size(); ++cIdx)
{
m_colors.add(colorArray[0]);
}
recomputeMaxTexCoord();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGeoMechCase::~RimGeoMechCase(void)
{
geoMechViews.deleteAllChildObjects();
RimProject* project = RiaApplication::instance()->project();
if (project)
{
if (project->mainPlotCollection())
{
RimWellLogPlotCollection* plotCollection = project->mainPlotCollection()->wellLogPlotCollection();
if (plotCollection)
{
plotCollection->removeExtractors(this->geoMechData());
}
}
}
if (this->geoMechData())
{
// At this point, we assume that memory should be released
CVF_ASSERT(this->geoMechData()->refCount() == 1);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCellPropertyFilter::computeResultValueRange()
{
CVF_ASSERT(m_parentContainer);
double min = 0.0;
double max = 0.0;
size_t scalarIndex = resultDefinition->scalarResultIndex();
if (scalarIndex != cvf::UNDEFINED_SIZE_T)
{
RimReservoirCellResultsStorage* results = resultDefinition->currentGridCellResults();
if (results)
{
results->cellResults()->minMaxCellScalarValues(scalarIndex, min, max);
}
}
m_maximumResultValue = max;
m_minimumResultValue = min;
lowerBound.setUiName(QString("Min (%1)").arg(min));
upperBound.setUiName(QString("Max (%1)").arg(max));
}
//--------------------------------------------------------------------------------------------------
/// Restart timer and laptime
//--------------------------------------------------------------------------------------------------
void Timer::restart()
{
CVF_ASSERT(m_timerState);
#ifdef WIN32
LARGE_INTEGER tick;
QueryPerformanceCounter(&tick);
m_timerState->m_startTick = tick.QuadPart;
m_timerState->m_lastLapTick = m_timerState->m_startTick;
#elif defined(CVF_LINUX) || defined(CVF_ANDROID)
clock_gettime(CLOCK_MONOTONIC, &m_timerState->m_timeStart);
m_timerState->m_timeMark = m_timerState->m_timeStart;
#elif defined(CVF_IOS) || defined(CVF_OSX)
m_timerState->m_startTime = mach_absolute_time();
m_timerState->m_lastLapTime = m_timerState->m_startTime;
#endif
}
