Foam::binaryOperationSearchableSurface::binaryOperationSearchableSurface
(
const IOobject& io,
const dictionary& dict
)
:
searchableSurface(io),
aName_(dict.lookupOrDefault<word>("aName","A")),
bName_(dict.lookupOrDefault<word>("bName","B")),
a_(
searchableSurface::New
(
word(dict.subDict("a").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+aName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("a")
)
),
b_(
searchableSurface::New
(
word(dict.subDict("b").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+bName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("b")
)
),
nrARegions_(
a().regions().size()
),
nrBRegions_(
b().regions().size()
)
{
if(aName_==bName_) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "'aName' and 'bName' have the same value " << aName_
<< " for " << name()
<< endl
<< exit(FatalError);
}
if(regions().size()!=size()) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "Number of regions " << regions().size() << " not equal to size "
<< size() << nl << "Regions: " << regions()
<< endl
<< exit(FatalError);
}
}
hsa_status_t GpuAgent::IterateRegion(
hsa_status_t (*callback)(hsa_region_t region, void* data),
void* data) const {
const size_t num_mems = regions().size();
for (size_t j = 0; j < num_mems; ++j) {
hsa_region_t region = core::MemoryRegion::Convert(regions()[j]);
hsa_status_t status = callback(region, data);
if (status != HSA_STATUS_SUCCESS) {
return status;
}
}
return HSA_STATUS_SUCCESS;
}
void CreateBug1117712LayerTree() {
const char* layerTreeSyntax = "c(c(t)t)";
// LayerID 0 1 2 3
// 0 is the root
// 1 is a container layer whose sole purpose to make a non-empty ancestor
// transform for 2, so that 2's screen-to-apzc and apzc-to-gecko
// transforms are different from 3's.
// 2 is a small layer that is the actual target
// 3 is a big layer obscuring 2 with a dispatch-to-content region
nsIntRegion layerVisibleRegions[] = {
nsIntRegion(IntRect(0, 0, 100, 100)),
nsIntRegion(IntRect(0, 0, 0, 0)),
nsIntRegion(IntRect(0, 0, 10, 10)),
nsIntRegion(IntRect(0, 0, 100, 100)),
};
Matrix4x4 layerTransforms[] = {
Matrix4x4(),
Matrix4x4::Translation(50, 0, 0),
Matrix4x4(),
Matrix4x4(),
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, layerTransforms, lm, layers);
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 10, 10));
SetScrollableFrameMetrics(layers[3], FrameMetrics::START_SCROLL_ID + 2, CSSRect(0, 0, 100, 100));
EventRegions regions(nsIntRegion(IntRect(0, 0, 10, 10)));
layers[2]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 100, 100));
regions.mDispatchToContentHitRegion = nsIntRegion(IntRect(0, 0, 100, 100));
layers[3]->SetEventRegions(regions);
registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
manager->UpdateHitTestingTree(nullptr, root, false, 0, 0);
}
virtual bool load(
const SfM_Data & sfm_data,
const std::string & feat_directory,
std::unique_ptr<features::Regions>& region_type)
{
C_Progress_display my_progress_bar( sfm_data.GetViews().size(),
std::cout, "\n- Features Loading -\n" );
// Read for each view the corresponding features and store them as PointFeatures
std::unique_ptr<features::Regions> regions(region_type->EmptyClone());
for (Views::const_iterator iter = sfm_data.GetViews().begin();
iter != sfm_data.GetViews().end(); ++iter, ++my_progress_bar)
{
const std::string sImageName = stlplus::create_filespec(sfm_data.s_root_path, iter->second.get()->s_Img_path);
const std::string basename = stlplus::basename_part(sImageName);
const std::string featFile = stlplus::create_filespec(feat_directory, basename, ".feat");
if (!regions->LoadFeatures(featFile))
{
std::cerr << "Invalid feature files for the view: " << sImageName << std::endl;
return false;
}
// save loaded Features as PointFeature
feats_per_view[iter->second.get()->id_view] = regions->GetRegionsPositions();
}
return true;
}
void MythUIEditBar::CalcInverseRegions(void)
{
m_invregions.clear();
bool first = true;
float start = 0.0f;
QListIterator<QPair<float, float> > regions(m_regions);
while (regions.hasNext())
{
QPair<float, float> region = regions.next();
if (first)
{
if (region.first > 0.0f)
m_invregions.append(qMakePair(start, region.first));
start = region.second;
first = false;
}
else
{
m_invregions.append(qMakePair(start, region.first));
start = region.second;
}
}
if (start < 1.0f)
m_invregions.append(qMakePair(start, 1.0f));
}
void LoadableTextTrack::addRegions(const HeapVector<Member<VTTRegion>>& newRegions)
{
for (size_t i = 0; i < newRegions.size(); ++i) {
newRegions[i]->setTrack(this);
regions()->add(newRegions[i]);
}
}
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
#include "readSolverOptions.H"
regionProperties regions(runTime);
//- Create mesh
#include "createFluidMeshes.H"
//- Create fields
forAll(fluidRegions, j)
{
if ( fluidsNames[j] == regionName )
{
#include "createBasicFields.H"
#include "createAdditionalFields.H"
#include "memoryAllocation.H"
#include "properties.H"
#include "finalSetupOperations.H"
#include "evaluatingArea.H"
#include "evaluatingConversion.H"
#include "evaluatingAtomBalance.H"
#include "evaluatingPressureDrops.H"
#include "evaluatingTransportProperties.H"
#include "evaluatingEnthalpyBalance.H"
#include "write.H"
}
}
return 0;
}
void CreateObscuringLayerTree() {
const char* layerTreeSyntax = "c(c(t)t)";
// LayerID 0 1 2 3
// 0 is the root.
// 1 is a parent scrollable layer.
// 2 is a child scrollable layer.
// 3 is the Obscurer, who ruins everything.
nsIntRegion layerVisibleRegions[] = {
// x coordinates are uninteresting
nsIntRegion(IntRect(0, 0, 200, 200)), // [0, 200]
nsIntRegion(IntRect(0, 0, 200, 200)), // [0, 200]
nsIntRegion(IntRect(0, 100, 200, 50)), // [100, 150]
nsIntRegion(IntRect(0, 100, 200, 100)) // [100, 200]
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID, CSSRect(0, 0, 200, 200));
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1, CSSRect(0, 0, 200, 300));
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 2, CSSRect(0, 0, 200, 100));
SetScrollHandoff(layers[2], layers[1]);
SetScrollHandoff(layers[1], root);
EventRegions regions(nsIntRegion(IntRect(0, 0, 200, 200)));
root->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 200, 300));
layers[1]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 100, 200, 100));
layers[2]->SetEventRegions(regions);
registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
manager->UpdateHitTestingTree(nullptr, root, false, 0, 0);
rootApzc = ApzcOf(root);
}
void LoadableTextTrack::addRegions(
const HeapVector<Member<VTTRegion>>& newRegions) {
for (const auto& region : newRegions) {
region->setTrack(this);
regions()->add(region);
}
}
void CreateEventRegionsLayerTree1() {
const char* layerTreeSyntax = "c(tt)";
nsIntRegion layerVisibleRegions[] = {
nsIntRegion(IntRect(0, 0, 200, 200)), // root
nsIntRegion(IntRect(0, 0, 100, 200)), // left half
nsIntRegion(IntRect(0, 100, 200, 100)), // bottom half
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID);
SetScrollableFrameMetrics(layers[1], FrameMetrics::START_SCROLL_ID + 1);
SetScrollableFrameMetrics(layers[2], FrameMetrics::START_SCROLL_ID + 2);
SetScrollHandoff(layers[1], root);
SetScrollHandoff(layers[2], root);
// Set up the event regions over a 200x200 area. The root layer has the
// whole 200x200 as the hit region; layers[1] has the left half and
// layers[2] has the bottom half. The bottom-left 100x100 area is also
// in the d-t-c region for both layers[1] and layers[2] (but layers[2] is
// on top so it gets the events by default if the main thread doesn't
// respond).
EventRegions regions(nsIntRegion(IntRect(0, 0, 200, 200)));
root->SetEventRegions(regions);
regions.mDispatchToContentHitRegion = nsIntRegion(IntRect(0, 100, 100, 100));
regions.mHitRegion = nsIntRegion(IntRect(0, 0, 100, 200));
layers[1]->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 100, 200, 100));
layers[2]->SetEventRegions(regions);
registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
manager->UpdateHitTestingTree(nullptr, root, false, 0, 0);
rootApzc = ApzcOf(root);
}
static bool skipFace(GFace *gf)
{
if(gf->physicals.size()) return false;
std::list<GRegion*> regions(gf->regions());
for(std::list<GRegion*>::iterator itr = regions.begin(); itr != regions.end(); itr++){
if(!skipRegion(*itr)) return false;
}
return true;
}
void InbandWebVTTTextTrack::newRegionsParsed()
{
Vector<RefPtr<VTTRegion>> newRegions;
parser().getNewRegions(newRegions);
for (auto& region : newRegions) {
region->setTrack(this);
regions()->add(region);
}
}
/// generates n_crops many regions of a given size within the boundaries of a given image img
std::vector<cv::RotatedRect> random_regions(const cv::Mat& img, int n_crops, float min_size_frac){
std::vector<cv::RotatedRect> regions(n_crops);
for(int i = 0; i<n_crops; i++){
float f = std::exp(drand48() * (std::log(1.f) - std::log(min_size_frac)) + std::log(min_size_frac));
float size = std::max(img.cols, img.rows) * f;
float max_x = img.cols - size;
float max_y = img.rows - size;
cv::Rect r(cv::Point2f(max_x * drand48(), max_y * drand48()), cv::Size(size,size));
regions[i] = cv::RotatedRect(cv::Point2f(r.x+size/2, r.y+size/2), cv::Size(size,size), 0.f);
}
return regions;
}
hsa_status_t GpuAgent::IterateRegion(
hsa_status_t (*callback)(hsa_region_t region, void* data),
void* data) const {
const size_t num_mems = regions().size();
for (size_t j = 0; j < num_mems; ++j) {
const MemoryRegion* amd_region =
reinterpret_cast<const MemoryRegion*>(regions()[j]);
// Skip memory regions other than host, gpu local, or LDS.
if (amd_region->IsSystem() || amd_region->IsLocalMemory() ||
amd_region->IsLDS()) {
hsa_region_t hsa_region = core::MemoryRegion::Convert(amd_region);
hsa_status_t status = callback(hsa_region, data);
if (status != HSA_STATUS_SUCCESS) {
return status;
}
}
}
return HSA_STATUS_SUCCESS;
}
Foam::label Foam::binaryOperationSearchableSurface::toIndexA(
const label index
) const
{
if(index>=nrARegions_) {
Info << "A: " << index << "/" << nrARegions_
<< " " << regions() << endl;
return -1;
// return 0;
} else {
return index;
}
}
void sceneTextDetector::set_Channels_Group(Mat image, int mode, int type, string xm, double prob)
{
//-----------------------------------------------------------------------------CSER
/*computeNMChannels(image, channels, mode);
int cn = (int)channels.size();
for (int c = 0; c < cn - 1; c++)
channels.push_back(255 - channels[c]);
for (int c = 0; c<(int)channels.size(); c++)
{
er_filter1->run(channels[c], regions[c]);
er_filter2->run(channels[c], regions[c]);
}*/
Mat grey;
vector<vector<ERStat> > regions(2);
cvtColor(image, grey, COLOR_RGB2GRAY);
channels.clear();
channels.push_back(grey);
channels.push_back(255 - grey);
regions[0].clear();
regions[1].clear();
nm_region_groups.clear();
nm_boxes.clear();
parallel_for_(cv::Range(0, (int)channels.size()), Parallel_extractCSER(channels, regions, er_filters1, er_filters2));
//-----------------------------------------------------------------------------MSER
/* vector<vector<Point> > contours;
vector<Rect> bboxes;
Mat grey;
cvtColor(image, grey, COLOR_RGB2GRAY);
channels.clear();
channels.push_back(grey);
channels.push_back(255 - grey);
regions.resize(channels.size());
nm_region_groups.clear();
nm_boxes.clear();
Ptr<MSER> mser = MSER::create(21, (int)(0.00002*grey.cols*grey.rows), (int)(0.05*grey.cols*grey.rows), 1, 0.7);
mser->detectRegions(grey, contours, bboxes);
if (contours.size() > 0)
MSERsToERStats(grey, contours, regions);*/
//-----------------------------------------------------------------------------
erGrouping(image, channels, regions, nm_region_groups, nm_boxes, type, xm, prob);
}
void AGGWindow::onPaint(wxPaintEvent& event) {
wxPaintDC dc(this);
wxCoord width, height;
dc.GetSize(&width, &height);
if (!bitmap || bitmap->GetWidth() != width || bitmap->GetHeight() != height)
init(width, height);
// Iterate over regions needing repainting
wxRegionIterator regions(GetUpdateRegion());
wxRect rect;
while (regions) {
rect = regions.GetRect();
dc.Blit(rect.x, rect.y, rect.width, rect.height, &memDC, rect.x, rect.y);
++regions;
}
}
size_t SkPictureRecord::size() const {
size_t result = 0;
size_t sizeData;
bitmaps(&sizeData);
result += sizeData;
matrices(&sizeData);
result += sizeData;
paints(&sizeData);
result += sizeData;
paths(&sizeData);
result += sizeData;
pictures(&sizeData);
result += sizeData;
regions(&sizeData);
result += sizeData;
result += streamlen();
return result;
}
virtual bool load(
const SfM_Data & sfm_data,
const std::string & feat_directory,
std::unique_ptr<features::Regions>& region_type)
{
C_Progress_display my_progress_bar( sfm_data.GetViews().size(),
std::cout, "\n- Features Loading -\n" );
// Read for each view the corresponding features and store them as PointFeatures
bool bContinue = true;
#ifdef OPENMVG_USE_OPENMP
#pragma omp parallel
#endif
for (Views::const_iterator iter = sfm_data.GetViews().begin();
iter != sfm_data.GetViews().end() && bContinue; ++iter)
{
#ifdef OPENMVG_USE_OPENMP
#pragma omp single nowait
#endif
{
const std::string sImageName = stlplus::create_filespec(sfm_data.s_root_path, iter->second.get()->s_Img_path);
const std::string basename = stlplus::basename_part(sImageName);
const std::string featFile = stlplus::create_filespec(feat_directory, basename, ".feat");
std::unique_ptr<features::Regions> regions(region_type->EmptyClone());
if (!regions->LoadFeatures(featFile))
{
std::cerr << "Invalid feature files for the view: " << sImageName << std::endl;
#ifdef OPENMVG_USE_OPENMP
#pragma omp critical
#endif
bContinue = false;
}
#ifdef OPENMVG_USE_OPENMP
#pragma omp critical
#endif
{
// save loaded Features as PointFeature
feats_per_view[iter->second.get()->id_view] = regions->GetRegionsPositions();
++my_progress_bar;
}
}
}
return bContinue;
}
int main(int argc, char** argv)
{
try
{
Random random;
Config config(*ParadoxNode::ParseFromFile("config.txt"));
EU4::RegionCollection regions(*ParadoxNode::ParseFromFile(config.GetEU4Path() + "map\\region.txt"));
LOG(LogLevel::Info) << "Determining generate area";
EU4::ProvinceIDCollection generateProvinceIDs;
for (const auto& provinceID : config.GetProvincesToGenerate())
generateProvinceIDs.AddProvince(provinceID);
for (const auto& regionName : config.GetRegionsToGenerate())
generateProvinceIDs.AddRegion(regions, regionName);
LOG(LogLevel::Debug) << "Generate provinces: " << generateProvinceIDs;
LOG(LogLevel::Info) << "Reading province tags";
TagProvinceNameMapping tagProvinceNameMapping(*ParadoxNode::ParseFromFile("province_tags.txt"));
LOG(LogLevel::Info) << "Reading EU4 provinces";
EU4::ProvinceCollection provinces(generateProvinceIDs.GetProvinceIDs(),
config.GetEU4Path() + "history\\provinces\\",
config.GetEU4Path() + "common\\province_names\\",
config.GetEU4Path() + "localisation\\");
provinces.ClearTags();
EU4::CountryCollection countries;
ProtoCountryCollection protoCountries;
LOG(LogLevel::Info) << "Generating proto-countries";
protoCountries.GenerateFromProvinces(provinces, generateProvinceIDs.GetProvinceIDs(), random);
LOG(LogLevel::Info) << "Creating countries";
protoCountries.CreateCountries(countries, tagProvinceNameMapping, random);
LOG(LogLevel::Info) << "Writing mod";
Mod mod(config.GetModName(), countries, provinces);
mod.WriteMod(config.GetEU4Path() + "mod\\");
}
catch (std::exception& e)
{
LOG(LogLevel::Error) << e.what();
}
}
void CopyContext::copyResource(const Resource* pDst, const Resource* pSrc)
{
const Buffer* pDstBuffer = dynamic_cast<const Buffer*>(pDst);
if (pDstBuffer)
{
const Buffer* pSrcBuffer = dynamic_cast<const Buffer*>(pSrc);
assert(pSrcBuffer && (pSrcBuffer->getSize() == pDstBuffer->getSize()));
copyBufferRegion(pDstBuffer, 0, pSrcBuffer, 0, pSrcBuffer->getSize());
}
else
{
const Texture* pSrcTex = dynamic_cast<const Texture*>(pSrc);
const Texture* pDstTex = dynamic_cast<const Texture*>(pDst);
assert(pSrcTex && pDstTex);
assert((pSrcTex->getArraySize() == pDstTex->getArraySize()) && (pSrcTex->getMipCount() == pDstTex->getMipCount()));
uint32_t mipCount = pSrcTex->getMipCount();
std::vector<VkImageCopy> regions(mipCount);
VkImageAspectFlags srcAspect = getAspectFlagsFromFormat(pSrcTex->getFormat());
VkImageAspectFlags dstAspect = getAspectFlagsFromFormat(pDstTex->getFormat());
uint32_t arraySize = pSrcTex->getArraySize();
for (uint32_t i = 0; i < mipCount; i++)
{
regions[i] = {};
regions[i].srcSubresource.aspectMask = srcAspect;
regions[i].srcSubresource.baseArrayLayer = 0;
regions[i].srcSubresource.layerCount = arraySize;
regions[i].srcSubresource.mipLevel = i;
regions[i].dstSubresource = regions[i].srcSubresource;
regions[i].dstSubresource.aspectMask = dstAspect;
regions[i].extent.width = pSrcTex->getWidth(i);
regions[i].extent.height = pSrcTex->getHeight(i);
regions[i].extent.depth = pSrcTex->getDepth(i);
}
resourceBarrier(pDst, Resource::State::CopyDest);
resourceBarrier(pSrc, Resource::State::CopySource);
vkCmdCopyImage(mpLowLevelData->getCommandList(), pSrc->getApiHandle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, pDst->getApiHandle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, mipCount, regions.data());
}
mCommandsPending = true;
}
static void _fix_caverns(dungeon_t* dungeon)
{
int* flood_map;
flood_map = new int[dungeon->width * dungeon->height];
for (int y = 0; y < dungeon->height; y++)
{
for (int x = 0; x < dungeon->width; x++)
{
int index = y * dungeon->width + x;
flood_map[index] = 1;
tile_t* tile = get_tile_at(dungeon, x, y);
if (tile->id == TILE_STONE_WALL)
{
flood_map[index] = 0;
}
}
}
unique_regions<int> regions(flood_map, dungeon->width, dungeon->height, 1);
TRACE("Number of unique regions: %d", regions.get().size());
regions.dump();
const unique_regions<int>::region* largest_region =
regions.get_largest_region();
for (size_t i = 0; i < regions.get().size(); i++)
{
const unique_regions<int>::region region = regions.get()[i];
if (region.id != largest_region->id)
{
TRACE("Removing region %d, with size %d", region.id, region.coords.size());
for (size_t j = 0; j < region.coords.size(); j++)
{
coord_t coord = region.coords[j];
set_tile_at(dungeon, coord.x, coord.y, TILES[TILE_STONE_WALL]);
}
}
}
delete[] flood_map;
}
void CreateEventRegionsLayerTree2() {
const char* layerTreeSyntax = "c(t)";
nsIntRegion layerVisibleRegions[] = {
nsIntRegion(IntRect(0, 0, 100, 500)),
nsIntRegion(IntRect(0, 150, 100, 100)),
};
root = CreateLayerTree(layerTreeSyntax, layerVisibleRegions, nullptr, lm, layers);
SetScrollableFrameMetrics(root, FrameMetrics::START_SCROLL_ID);
// Set up the event regions so that the child thebes layer is positioned far
// away from the scrolling container layer.
EventRegions regions(nsIntRegion(IntRect(0, 0, 100, 100)));
root->SetEventRegions(regions);
regions.mHitRegion = nsIntRegion(IntRect(0, 150, 100, 100));
layers[1]->SetEventRegions(regions);
registration = MakeUnique<ScopedLayerTreeRegistration>(manager, 0, root, mcc);
manager->UpdateHitTestingTree(nullptr, root, false, 0, 0);
rootApzc = ApzcOf(root);
}
void ExtractTexto::Segmentar( cv::Mat const & source, std::vector<cv::Rect> &groups_boxes ){
std::vector<cv::Mat> channels;
cv::text::computeNMChannels(source, channels);
groups_boxes.clear();
int cn = (int)channels.size();
for (int c = 0; c < cn-1; c++)
channels.push_back(channels[c]);
//Ptr<cv::text::ERFilter> er_filter1 = createERFilterNM1(loadClassifierNM1("trained_classifierNM1.xml"), 11, 0.00005, 0.2, 0.8, true, 0.5);
Ptr<cv::text::ERFilter> er_filter1 = createERFilterNM1(loadClassifierNM1("trained_classifierNM1.xml"), 13, 0.0005, 0.2, 0.5, true, 0.5);
Ptr<cv::text::ERFilter> er_filter2 = createERFilterNM2(loadClassifierNM2("trained_classifierNM2.xml"), 0.5);
std::vector< std::vector<cv::text::ERStat> > regions(channels.size());
for (int c=0; c<(int)channels.size(); c++){
er_filter1->run(channels[c], regions[c]);
er_filter2->run(channels[c], regions[c]);
}
std::vector< std::vector<Vec2i>> region_groups;
cv::text::erGrouping(source, channels, regions, region_groups, groups_boxes, ERGROUPING_ORIENTATION_HORIZ);
cv::Mat imagClone = source.clone();
findSuperRect(groups_boxes, groups_boxes);
groups_draw(imagClone, groups_boxes);
er_filter1.release();
er_filter2.release();
regions.clear();
}
logical pc_ADK_FieldControl :: AddRegion (char *propnames, int32 indx0 )
{
pc_ADK_Field regions(GPH("regions"));
char propname[ID_SIZE];
logical term = NO;
BEGINSEQ
if ( indx0 >= regions.GetCount() )
indx0 = LAST_INSTANCE;
gvtxstb(propname,propnames,ID_SIZE);
regions.Add(indx0,propnames); CTXCERR
regions.Save(); CTXCERR
SetActionResult(regions.GPH("sys_ident")->GetString());
RECOVER
SetActionResult("");
term = YES;
ENDSEQ
return(term);
}
std::vector<bool>
EefcFlash::getLockRegions()
{
std::vector<bool> regions(_lockRegions);
uint32_t frr;
uint32_t bit;
waitFSR();
for (uint32_t region = 0; region < _lockRegions; region++)
{
if (_planes == 2 && region >= _lockRegions / 2)
{
bit = region - _lockRegions / 2;
writeFCR1(EEFC_FCMD_GLB, 0);
waitFSR();
frr = readFRR1();
while (bit >= 32)
{
frr = readFRR1();
bit -= 32;
}
regions[region] = (frr & (1 << bit)) != 0;
}
else
{
bit = region;
writeFCR0(EEFC_FCMD_GLB, 0);
waitFSR();
frr = readFRR0();
while (bit >= 32)
{
frr = readFRR0();
bit -= 32;
}
regions[region] = (frr & (1 << bit)) != 0;
}
}
return regions;
}
void MythUIEditBar::Display(void)
{
QRect keeparea = QRect();
QRect cutarea = QRect();
MythUIType *position = GetChild("position");
MythUIType *keep = GetChild("keep");
MythUIType *cut = GetChild("cut");
MythUIType *cuttoleft = GetChild("cuttoleft");
MythUIType *cuttoright = GetChild("cuttoright");
MythUIType *keeptoleft = GetChild("keeptoleft");
MythUIType *keeptoright = GetChild("keeptoright");
if (position)
position->SetVisible(false);
if (keep)
{
keep->SetVisible(false);
keeparea = keep->GetArea();
}
if (cut)
{
cut->SetVisible(false);
cutarea = cut->GetArea();
}
if (cuttoleft)
cuttoleft->SetVisible(false);
if (cuttoright)
cuttoright->SetVisible(false);
if (keeptoleft)
keeptoleft->SetVisible(false);
if (keeptoright)
keeptoright->SetVisible(false);
if (position && keeparea.isValid())
{
int offset = position->GetArea().width() / 2;
int newx = (int)(((float)keeparea.width() * m_editPosition) + 0.5f);
int newy = position->GetArea().top();
position->SetPosition(newx - offset, newy);
position->SetVisible(true);
}
ClearImages();
if (!m_regions.size())
{
if (keep)
keep->SetVisible(true);
return;
}
MythUIShape *barshape = dynamic_cast<MythUIShape *>(cut);
MythUIImage *barimage = dynamic_cast<MythUIImage *>(cut);
MythUIShape *leftshape = dynamic_cast<MythUIShape *>(cuttoleft);
MythUIImage *leftimage = dynamic_cast<MythUIImage *>(cuttoleft);
MythUIShape *rightshape = dynamic_cast<MythUIShape *>(cuttoright);
MythUIImage *rightimage = dynamic_cast<MythUIImage *>(cuttoright);
QListIterator<QPair<float, float> > regions(m_regions);
while (regions.hasNext() && cutarea.isValid())
{
QPair<float, float> region = regions.next();
int left = (int)((region.first * cutarea.width()) + 0.5f);
int right = (int)((region.second * cutarea.width()) + 0.5f);
if (left >= right)
right = left + 1;
if (cut)
{
AddBar(barshape, barimage, QRect(left, cutarea.top(), right - left,
cutarea.height()));
}
if (cuttoleft && (region.second < 1.0f))
AddMark(leftshape, leftimage, right, true);
if (cuttoright && (region.first > 0.0f))
AddMark(rightshape, rightimage, left, false);
}
CalcInverseRegions();
barshape = dynamic_cast<MythUIShape *>(keep);
barimage = dynamic_cast<MythUIImage *>(keep);
leftshape = dynamic_cast<MythUIShape *>(keeptoleft);
leftimage = dynamic_cast<MythUIImage *>(keeptoleft);
rightshape = dynamic_cast<MythUIShape *>(keeptoright);
rightimage = dynamic_cast<MythUIImage *>(keeptoright);
QListIterator<QPair<float, float> > regions2(m_invregions);
while (regions2.hasNext() && keeparea.isValid())
{
QPair<float, float> region = regions2.next();
int left = (int)((region.first * keeparea.width()) + 0.5f);
int right = (int)((region.second * keeparea.width()) + 0.5f);
if (left >= right)
right = left + 1;
if (keep)
{
AddBar(barshape, barimage, QRect(left, keeparea.top(), right - left,
keeparea.height()));
}
if (keeptoleft && (region.second < 1.0f))
AddMark(leftshape, leftimage, right, true);
if (keeptoright && (region.first > 0.0f))
AddMark(rightshape, rightimage, left, false);
}
if (position)
position->MoveToTop();
}
int
TriMesh::mesh(double alpha, const ID& rtags2, const ID& rtags)
{
// get all regions
int numregions = rtags.Size()+rtags2.Size();
int numpoints = 0;
std::vector<MeshRegion*> regions(numregions);
for(int i=0; i<rtags.Size(); i++) {
MeshRegion* region = theDomain->getRegion(rtags(i));
if(region == 0) {
opserr<<"WARNING: region "<<rtags(i)<<" is not defined\n";
return -1;
}
numpoints += region->getNodes().Size();
regions[i] = region;
}
for(int i=0; i<rtags2.Size(); i++) {
MeshRegion* region = theDomain->getRegion(rtags2(i));
if(region == 0) {
opserr<<"WARNING: region "<<rtags2(i)<<" is not defined\n";
return -1;
}
numpoints += region->getNodes().Size();
regions[i+rtags.Size()] = region;
// remove elements
const ID& eles = region->getExtraEles();
for (int j=0; j<eles.Size(); j++) {
Element* ele = theDomain->removeElement(eles(j));
if (ele != 0) {
delete ele;
}
}
}
// get all points
ID ptreg(0,numpoints), ptnode(0,numpoints);
for(int i=0; i<numregions; i++) {
const ID& nodes = regions[i]->getNodes();
for(int j=0; j<nodes.Size(); j++) {
int index = ptreg.Size();
ptreg[index] = i;
ptnode[index] = nodes(j);
}
}
// calling mesh generator
TriangleMeshGenerator gen;
for(int i=0; i<ptnode.Size(); i++) {
// get node
Node* theNode = theDomain->getNode(ptnode(i));
if(theNode == 0) {
opserr<<"WARNING: node "<<ptnode(i)<<" is not defined\n";
return -1;
}
const Vector& crds = theNode->getCrds();
const Vector& disp = theNode->getTrialDisp();
if(crds.Size() < 2 || disp.Size() < 2) {
opserr<<"WARNING: ndm < 2 or ndf < 2\n";
return -1;
}
// add point
gen.addPoint(crds(0)+disp(0), crds(1)+disp(1));
}
// meshing
gen.remesh(alpha);
// get elenodes
std::vector<ID> regelenodes(rtags2.Size());
for(int i=0; i<gen.getNumTriangles(); i++) {
int p1,p2,p3;
gen.getTriangle(i,p1,p2,p3);
// if all connected to fixed regions
int numfix = rtags.Size();
if(ptreg(p1)<numfix && ptreg(p2)<numfix && ptreg(p3)<numfix) {
continue;
}
// which region it belongs to
int reg = ptreg(p1);
if(reg<numfix || (reg>ptreg(p2) && ptreg(p2)>=numfix)) reg = ptreg(p2);
if(reg<numfix || (reg>ptreg(p3) && ptreg(p3)>=numfix)) reg = ptreg(p3);
reg -= numfix;
// elenodes
int index = regelenodes[reg].Size();
regelenodes[reg][index++] = ptnode(p1);
regelenodes[reg][index++] = ptnode(p2);
regelenodes[reg][index++] = ptnode(p3);
}
// all elenodes
ID allelenodes;
for(int i=0; i<(int)regelenodes.size(); i++) {
int num = allelenodes.Size();
int num1 = regelenodes[i].Size();
allelenodes.resize(num+num1);
for (int j=0; j<num1; j++) {
allelenodes(num+j) = regelenodes[i](j);
}
}
// create elements
std::string eletype = OPS_GetString();
ID eletags;
if (eletype=="PFEMElement2D") {
if (OPS_PFEMElement2D(*theDomain,allelenodes,eletags) < 0) {
return -1;
}
} else if (eletype=="PFEMElement2DQuasi") {
if (OPS_PFEMElement2DCompressible(*theDomain,allelenodes,eletags) < 0) {
return -1;
}
} else if (eletype=="PFEMElement2DBubble") {
if (OPS_PFEMElement2DBubble(*theDomain,allelenodes,eletags) < 0) {
return -1;
}
} else if (eletype=="tri31") {
if (OPS_Tri31(*theDomain,allelenodes,eletags) < 0) {
return -1;
}
} else {
opserr<<"WARNING: element "<<eletype.c_str()<<" can't be used for tri mesh at this time\n";
return -1;
}
// add to region
int num = 0;
for(int i=rtags.Size(); i<numregions; i++) {
int num1 = regelenodes[i-rtags.Size()].Size()/3;
ID eletag(num1);
for (int j=0; j<num1; j++) {
eletag(j) = eletags(num+j);
}
num += num1;
regions[i]->setExtraEles(eletag);
}
return 0;
}
Foam::binaryOperationSearchableSurface::binaryOperationSearchableSurface
(
const IOobject& io,
const dictionary& dict
)
:
searchableSurface(io),
aName_(dict.lookupOrDefault<word>("aName","A")),
bName_(dict.lookupOrDefault<word>("bName","B")),
a_(
searchableSurface::New
(
word(dict.subDict("a").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+aName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("a")
)
),
b_(
searchableSurface::New
(
word(dict.subDict("b").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+bName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("b")
)
),
nrARegions_(
a().regions().size()
),
nrBRegions_(
b().regions().size()
)
{
if(aName_==bName_) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "'aName' and 'bName' have the same value " << aName_
<< " for " << name()
<< endl
<< exit(FatalError);
}
if(regions().size()!=size()) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "Number of regions " << regions().size() << " not equal to size "
<< size() << nl << "Regions: " << regions()
<< endl
<< exit(FatalError);
}
#ifdef FOAM_SEARCHABLE_SURF_HAS_BOUND_METHOD
pointField pts(4);
pts[0]=a().bounds().min();
pts[1]=a().bounds().max();
pts[2]=b().bounds().min();
pts[3]=b().bounds().max();
bounds()=boundBox(pts);
#endif
}
bool OCRTess::detectAndRecog() {
UMat grey = UMat::zeros(this->img.rows + 2, this->img.cols + 2, CV_8UC1);
cvtColor(this->img.clone(), grey, COLOR_RGB2GRAY);
vector<UMat> channels;
channels.clear();
channels.push_back(grey);
Mat m = 255 - grey.getMat(ACCESS_READ | ACCESS_WRITE);
channels.push_back(m.getUMat(ACCESS_READ));
vector<vector<ERStat>> regions(2);
regions[0].clear();
regions[1].clear();
switch (this->REGION) {
case REG_CSER: {
parallel_for_(Range(0, (int) channels.size()), Parallel_extractCSER(channels, regions, this->erf1, this->erf2));
break;
}
case REG_MSER: {
vector<vector<Point> > contours;
vector<Rect> bboxes;
Ptr<MSER> mser = MSER::create(21, (int) (0.00002 * grey.cols * grey.rows), (int) (0.05 * grey.cols * grey.rows), 1, 0.7);
mser->detectRegions(grey, contours, bboxes);
if (contours.size() > 0)
MSERsToERStats(grey, contours, regions);
break;
}
default: {
break;
}
}
/*Text Recognition (OCR)*/
vector<vector<Vec2i> > nm_region_groups;
vector<Rect> nm_boxes;
switch (this->GROUP) {
case 0:
erGrouping(this->img, channels, regions, nm_region_groups, nm_boxes, ERGROUPING_ORIENTATION_HORIZ);
break;
case 1:
default:
erGrouping(this->img, channels, regions, nm_region_groups, nm_boxes, ERGROUPING_ORIENTATION_ANY, DIR + TR_GRP, 0.5);
break;
}
if (!nm_boxes.size() || nm_boxes.size() > 1) return false;
vector<string> words_detection;
float min_confidence1 = 51.f, min_confidence2 = 60.f;
vector<UMat> detections;
for (int i = 0; i < (int) nm_boxes.size(); i++) {
// rectangle(this->out, nm_boxes[i].tl(), nm_boxes[i].br(), Scalar(255, 255, 0), 3);
UMat group_img = UMat::zeros(this->img.rows + 2, this->img.cols + 2, CV_8UC1);
er_draw(channels, regions, nm_region_groups[i], group_img);
group_img = group_img(nm_boxes[i]);
copyMakeBorder(group_img.clone(), group_img, 15, 15, 15, 15, BORDER_CONSTANT, Scalar(0));
detections.push_back(group_img);
}
vector<string> outputs((int) detections.size());
vector<vector<Rect> > boxes((int) detections.size());
vector<vector<string> > words((int) detections.size());
vector<vector<float> > confidences((int) detections.size());
if (!detections.size() || detections.size() > 1) return false;
for (int i = 0; i < (int) detections.size(); i = i + this->num) {
Range r;
if (i + this->num <= (int) detections.size()) r = Range(i, i + this->num);
else r = Range(i, (int) detections.size());
parallel_for_(r, Parallel_OCR<OCRTesseract>(detections, outputs, boxes, words, confidences, this->ocrs));
}
for (int i = 0; i < (int) detections.size(); i++) {
outputs[i].erase(remove(outputs[i].begin(), outputs[i].end(), '\n'), outputs[i].end());
if (outputs[i].size() < 3) {
continue;
}
for (int j = 0; j < (int) boxes[i].size(); j++) {
boxes[i][j].x += nm_boxes[i].x - 15;
boxes[i][j].y += nm_boxes[i].y - 15;
if ((words[i][j].size() < 2) || (confidences[i][j] < min_confidence1) ||
((words[i][j].size() == 2) && (words[i][j][0] == words[i][j][1])) ||
((words[i][j].size() < 4) && (confidences[i][j] < min_confidence2)) ||
isRepetitive(words[i][j]))
continue;
words_detection.push_back(words[i][j]);
// rectangle(this->out, boxes[i][j].tl(), boxes[i][j].br(), Scalar(255, 0, 255), 3);
// Size word_size = getTextSize(words[i][j], FONT_HERSHEY_SIMPLEX, (double) scale_font, (int) (3 * scale_font), NULL);
// rectangle(this->out, boxes[i][j].tl() - Point(3, word_size.height + 3), boxes[i][j].tl() + Point(word_size.width, 0), Scalar(255, 0, 255), -1);
// putText(this->out, words[i][j], boxes[i][j].tl() - Point(1, 1), FONT_HERSHEY_SIMPLEX, scale_font, Scalar(255, 255, 255), (int) (3 * scale_font));
}
}
if (!words_detection.size() || words_detection.size() > 1) return false;
return (words_detection[0].compare(WORD) == 0);
}
