Skip to content

Commit

Permalink
Fixed #172
Browse files Browse the repository at this point in the history
  • Loading branch information
@MaartenHilferink
MaartenHilferink committed Mar 13, 2023
1 parent 187ccf3 commit fb981ca
Show file tree
Hide file tree
Showing 3 changed files with 99 additions and 65 deletions.
104 changes: 66 additions & 38 deletions geo/dll/src/OperPolygon.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1649,10 +1649,10 @@ class PointInAllPolygonsOperator : public AbstrPointInAllPolygonsOperator
typedef DataArray<PointType> Arg1Type;
typedef DataArray<PolygonType> Arg2Type;

using ResDataElemType = Point<SizeT>;

typedef std::vector<ResDataElemType> ResTileDataType;
typedef std::map<Point<tile_id>, ResTileDataType> ResDataType;
using ResDataElemType = std::pair<tile_offset, tile_offset>;
using ResTileDataType = std::vector<ResDataElemType>;
using DualTileKey = std::pair<tile_id, tile_id>;
using ResDataType = std::map<DualTileKey, ResTileDataType>;

typedef typename scalar_of<PointType>::type ScalarType;
typedef SpatialIndex<ScalarType, typename Arg2Type::const_iterator> SpatialIndexType;
Expand Down Expand Up @@ -1706,15 +1706,11 @@ class PointInAllPolygonsOperator : public AbstrPointInAllPolygonsOperator
auto pointArray = pointData->GetTile(t);
auto polyArray = polyData->GetTile(u);

SizeT p1Offset = pointDataA->GetAbstrDomainUnit()->GetTileFirstIndex(t);
SizeT p2Offset = polyDataA->GetAbstrDomainUnit()->GetTileFirstIndex(u);

const SpatialIndexType* spIndexPtr = GetOptional<SpatialIndexType>(polyInfoHandle);

typedef typename SpatialIndexType::template iterator<BoxType> box_iter_type;
typedef typename scalar_of<P>::type coordinate_type;

typedef ResDataElemType res_data_elem_type;
using box_iter_type = typename SpatialIndexType::template iterator<BoxType> ;
using coordinate_type = typename scalar_of<P>::type ;
using res_data_elem_type = ResDataElemType;

ResTileDataType* resTileData = nullptr;
if (!resTileData)
Expand All @@ -1724,34 +1720,30 @@ class PointInAllPolygonsOperator : public AbstrPointInAllPolygonsOperator
if (!resDataHandle)
resDataHandle = makeResource<ResDataType>();
ResDataType& resData = GetAs<ResDataType>(resDataHandle);
resTileData = &(resData[Point<tile_id>(t, u)]);
resTileData = &(resData[DualTileKey(t, u)]);
}
dms_assert(resTileData);

leveled_critical_section resLocalAdditionSection(item_level_type(0), ord_level_type::SpecificOperator, "Polygon.LocalAdditionSection");

parallel_for(SizeT(0), pointArray.size(), [p1Offset, p2Offset, &pointArray, &polyArray, spIndexPtr, resTileData, &resLocalAdditionSection](SizeT i)->void
parallel_for(tile_offset(0), tile_offset(pointArray.size()),
[&pointArray, &polyArray, spIndexPtr, resTileData, &resLocalAdditionSection]
(tile_offset pointTileOffset)->void
{
auto pointPtr = pointArray.begin() + i;
SizeT p1_rel = p1Offset + i;
// BoxType bbox = RangeFromSequence(polyPtr->begin(), polyPtr->end());
auto pointPtr = pointArray.begin() + pointTileOffset;
if (!::IsIntersecting(spIndexPtr->GetBoundingBox(), *pointPtr))
return;

// box_iter_type iter;
for (auto iter = spIndexPtr->begin(*pointPtr); iter; ++iter)
{
if (IsInside(*((*iter)->get_ptr()), *pointPtr))
{
res_data_elem_type back;
back.first = p1_rel;
back.second = p2Offset + (((*iter)->get_ptr()) - polyArray.begin());

leveled_critical_section::scoped_lock resLock(resLocalAdditionSection);
resTileData->push_back(std::move(back));
resTileData->emplace_back(pointTileOffset, (*iter)->get_ptr() - polyArray.begin());
}
}
});
}
);
}

void StoreRes(AbstrUnit* res, AbstrDataItem* res1, AbstrDataItem* res2, ResourceHandle& resDataHandle) const override
Expand All @@ -1764,26 +1756,62 @@ class PointInAllPolygonsOperator : public AbstrPointInAllPolygonsOperator
count += resTiles.second.size();
res->SetCount(count);

locked_tile_write_channel<UInt32> res1Writer(res1);
locked_tile_write_channel<UInt32> res2Writer(res2);

if (resData)
{
for (auto& resTiles : *resData) // ordered by (t, u)
{
ResTileDataType& resTileData = resTiles.second;
std::sort(resTileData.begin(), resTileData.end()); // sort on (m_OrgRel)
std::vector<ResDataType::value_type> resTileDataArray; resTileDataArray.reserve(resData->size());
for (auto& resTileData : *resData)
resTileDataArray.emplace_back(std::move(resTileData));

for (auto& resElemData : resTileData)
parallel_for<SizeT>(0, resTileDataArray.size()
, [&resTileDataArray](SizeT t)
{
if (res1) res1Writer.Write(resElemData.first);
if (res2) res2Writer.Write(resElemData.second);
}
}
auto& resTileData = resTileDataArray[t];
std::sort(resTileData.second.begin(), resTileData.second.end()); // sort on (m_OrgRel)
});
if (res1)
visit<typelists::domain_elements>(res1->GetAbstrValuesUnit()
, [res1, &resTileDataArray]<typename P>(const Unit<P>* resValuesUnit)
{
locked_tile_write_channel<P> resWriter(res1);
auto tileRangeDataPtr = resValuesUnit->GetCurrSegmInfo();
MG_CHECK(tileRangeDataPtr);

for (auto& resTiles : resTileDataArray) // ordered by (t, u)
{
ResTileDataType& resTileData = resTiles.second;

for (auto& resElemData : resTileData)
resWriter.Write(tileRangeDataPtr->GetTileValue(resTiles.first.first, resElemData.first));
}
MG_CHECK(resWriter.IsEndOfChannel());
resWriter.Commit();
}
);
if (res2)
visit<typelists::domain_elements>(res2->GetAbstrValuesUnit()
, [res2, &resTileDataArray]<typename P>(const Unit<P>*resValuesUnit)
{
locked_tile_write_channel<P> resWriter(res2);
auto tileRangeDataPtr = resValuesUnit->GetCurrSegmInfo();
MG_CHECK(tileRangeDataPtr);

for (auto& resTiles : resTileDataArray) // ordered by (t, u)
{
ResTileDataType& resTileData = resTiles.second;

for (auto& resElemData : resTileData)
resWriter.Write(tileRangeDataPtr->GetTileValue(resTiles.first.second, resElemData.second));
}
MG_CHECK(resWriter.IsEndOfChannel());
resWriter.Commit();
}
);
}
else
{
if (res1) { DataWriteLock wr1(res1); wr1.Commit(); }
if (res2) { DataWriteLock wr2(res2); wr2.Commit(); }
}
auto tn = res->GetNrTiles();
if (res1) { MG_CHECK(res1Writer.IsEndOfChannel()); res1Writer.Commit(); }
if (res2) { MG_CHECK(res2Writer.IsEndOfChannel()); res2Writer.Commit(); }
}
};

Expand Down
46 changes: 25 additions & 21 deletions tic/dll/src/TiledRangeData.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -123,22 +123,28 @@ struct SmallRangeData : AbstrTileRangeData
row_id GetRangeSize() const override { return Cardinality(GetRange()); }

tile_id GetNrTiles() const override { return 1; }
tile_offset GetTileSize(tile_id t) const override { dms_assert(t == 0); return GetRangeSize(); }
tile_offset GetTileSize(tile_id t) const override { assert(t == 0); return GetRangeSize(); }
tile_offset GetMaxTileSize() const override { return GetRangeSize(); }
tile_loc GetTiledLocation(row_id index) const override { return { 0, index }; }

I64Rect GetRangeAsI64Rect() const override { return { {0, 0}, shp2dms_order(GetRangeSize(), row_id(1))}; }
I64Rect GetTileRangeAsI64Rect(tile_id t) const { dms_assert(t == 0 || t == no_tile); return GetRangeAsI64Rect(); }
row_id GetFirstRowIndex(tile_id t) const override { dms_assert(t == 0); return 0; }
row_id GetRowIndex(tile_id t, tile_offset localIndex) const override { dms_assert(t == 0); return localIndex; }
I64Rect GetTileRangeAsI64Rect(tile_id t) const { assert(t == 0 || t == no_tile); return GetRangeAsI64Rect(); }
row_id GetFirstRowIndex(tile_id t) const override { assert(t == 0); return 0; }
row_id GetRowIndex(tile_id t, tile_offset localIndex) const override { assert(t == 0); return localIndex; }

// range_t(dependent on T) specific functions, non virtual
Range<V> GetTileRange(tile_id t) const { dms_assert(t == 0); return GetRange(); }
Range<V> GetTileRange(tile_id t) const { assert(t == 0); return GetRange(); }
row_id GetElemCount() const { return GetRangeSize(); }
bool IsFirstValueZero() const { return m_Range.first == 0; }

auto GetAsLispRef(LispPtr base) const -> LispRef override;

V GetTileValue(tile_id t, tile_offset localIndex) const
{
assert(t == 0);
return Range_GetValue_checked(m_Range, localIndex);
}

Range<V> m_Range;
};

Expand All @@ -149,32 +155,30 @@ struct FixedRange : AbstrTileRangeData
return Range<UInt32>(0, 1 << N);
}
tile_id GetNrTiles() const override { return 1; }
tile_offset GetTileSize(tile_id t) const override { dms_assert(t == 0); return GetRangeSize(); }
tile_offset GetTileSize(tile_id t) const override { assert(t == 0); return GetRangeSize(); }
tile_offset GetMaxTileSize() const override { return GetRangeSize(); }
tile_loc GetTiledLocation(row_id index) const override { dms_assert(index < (1 << N)); return { 0, index }; }
tile_loc GetTiledLocation(row_id index) const override { assert(index < (1 << N)); return { 0, index }; }
row_id GetRangeSize() const override { return 1 << N; }

I64Rect GetRangeAsI64Rect() const override { return { {0, 0}, shp2dms_order(1 << N, 1) }; }
I64Rect GetTileRangeAsI64Rect(tile_id t) const { dms_assert(t == 0 || t==no_tile); return GetRangeAsI64Rect(); }
row_id GetFirstRowIndex(tile_id t) const override { dms_assert(t == 0); return 0; }
row_id GetRowIndex(tile_id t, tile_offset localIndex) const override { dms_assert(t == 0); return localIndex; }
I64Rect GetTileRangeAsI64Rect(tile_id t) const { assert(t == 0 || t==no_tile); return GetRangeAsI64Rect(); }
row_id GetFirstRowIndex(tile_id t) const override { assert(t == 0); return 0; }
row_id GetRowIndex(tile_id t, tile_offset localIndex) const override { assert(t == 0); return localIndex; }

// range_t(dependent on T) specific functions, non virtual
Range<UInt32> GetTileRange(tile_id t) const { dms_assert(t == 0); return GetRange(); }
Range<UInt32> GetTileRange(tile_id t) const { assert(t == 0); return GetRange(); }
row_id GetElemCount() const { return GetRangeSize(); }
bool IsFirstValueZero() const { return true; }

LispRef GetAsLispRef(LispPtr base) const override { return base; }
};
bit_value<N> GetTileValue(tile_id t, tile_offset localIndex) const
{
assert(t == 0);
assert(localIndex < (1 << N));
return localIndex;
}

/*
template <bit_size_t N>
struct FixedRangeVirtualPtr : FixedRange<N> // pseudo pointer to no object specific data
{
auto operator ->() const -> const FixedRange<N>* { return this; }
operator bool() const { return true; }
LispRef GetAsLispRef(LispPtr base) const override { return base; }
};
*/

template <typename V>
struct TiledRangeData : AbstrTileRangeData
Expand Down Expand Up @@ -231,7 +235,7 @@ struct TiledRangeData : AbstrTileRangeData
}
V GetTileValue(tile_id t, tile_offset localIndex) const
{
dms_assert(t != no_tile);
assert(t != no_tile);
return Range_GetValue_checked(GetTileRange(t), localIndex);
}
row_id GetFirstRowIndex(tile_id t) const override
Expand Down
14 changes: 8 additions & 6 deletions tic/dll/src/Unit.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -295,25 +295,27 @@ struct BitUnitBase : UnitBase<bit_value<N>>

typedef bit_value<N> value_t;
typedef Range<UInt32> range_t;
using range_data_t = FixedRange<N>;

static const UInt32 elem_count = mpf::exp2<N>::value;

auto GetTiledRangeData() const -> const AbstrTileRangeData* override {
static SharedPtr<FixedRange<N>> s_RangeData = new FixedRange<N>;
return s_RangeData;
}
auto GetTiledRangeData() const -> const AbstrTileRangeData* override { return GetCurrSegmInfo(); }

range_t GetRange() const { return range_t(0, elem_count); }
// range_t GetPreparedRange() const { return GetRange(); }

range_t GetTileRange(tile_id t) const { dms_assert(t == 0); return range_t(0, elem_count); }
// range_t GetPreparedTileRange(tile_id t) const { return GetTileRange(t); }

SharedStr GetRangeAsStr() const override { return AsString(GetRange()); }

// Support for Numerics; TODO merge this func with the NumericUnitAdapter version
value_t GetValueAtIndex (SizeT i) const { return i; }
SizeT GetIndexForValue(value_t v) const { return v; }

auto GetCurrSegmInfo() const -> const range_data_t* {
static SharedPtr<range_data_t> s_RangeData = new range_data_t;
return s_RangeData;
}
auto GetSegmInfo() const -> const range_data_t* { return GetCurrSegmInfo(); }
};

//----------------------------------------------------------------------
Expand Down

0 comments on commit fb981ca

Please sign in to comment.