static void check1d(const char* name, IntList x) {
if (x.size() != 1) {
std::ostringstream ss;
ss << "max_pool1d() argument '" << name << "' should contain one int (got "
<< x.size() << ")";
throw std::runtime_error(ss.str());
}
}
static std::vector<int64_t> defaultStrides(IntList sizes) {
std::vector<int64_t> strides(sizes.size());
int64_t stride = 1;
for(size_t i = sizes.size(); i > 0; --i) {
strides[i-1] = stride;
stride *= sizes[i-1];
}
return strides;
}
bool should_expand(const IntList &from_size, const IntList &to_size) {
if(from_size.size() > to_size.size()) {
return false;
}
for (auto from_dim_it = from_size.rbegin(); from_dim_it != from_size.rend(); ++from_dim_it) {
for (auto to_dim_it = to_size.rbegin(); to_dim_it != to_size.rend(); ++to_dim_it) {
if (*from_dim_it != 1 && *from_dim_it != *to_dim_it) {
return false;
}
}
}
return true;
}
void DefaultHttpHeader::set(const std::string& name, const IntList& values) {
StringList list;
for (size_t i = 0; i < values.size(); ++i) {
list.push_back(Integer::toString(values[i]));
}
set(name, list);
}
void checkSize(CheckedFrom c, const TensorGeometryArg& t, IntList sizes) {
checkDim(c, t, sizes.size());
if (!t->sizes().equals(sizes)) {
std::ostringstream oss;
oss << "Expected tensor of size " << sizes << ", but got tensor of size "
<< t->sizes() << " for " << t
<< " (while checking arguments for " << c << ")";
throw std::runtime_error(oss.str());
}
}
bool getVersion_(const String& version, MyriMatchVersion& myrimatch_version_i) const
{
// we expect three components
IntList nums = ListUtils::create<Int>(ListUtils::create<String>(version, '.'));
if (nums.size() != 3) return false;
myrimatch_version_i.myrimatch_major = nums[0];
myrimatch_version_i.myrimatch_minor = nums[1];
myrimatch_version_i.myrimatch_patch = nums[2];
return true;
}
static int64_t computeStorageSize(IntList sizes, IntList strides) {
// size of the underlying storage is 1 bigger than the offset
// of the last element according to stride
int64_t size = 1;
for(size_t i = 0; i < sizes.size(); i++) {
if(sizes[i] == 0) {
return 0;
}
size += strides[i]*(sizes[i]-1);
}
return size;
}
std::vector<int64_t> conv_output_size(
IntList input_size, IntList weight_size,
IntList padding, IntList stride, IntList dilation)
{
auto dim = input_size.size();
std::vector<int64_t> output_size(dim);
output_size[0] = input_size[input_batch_size_dim];
output_size[1] = weight_size[weight_output_channels_dim];
for (size_t d = 2; d < dim; ++d) {
auto kernel = dilation[d - 2] * (weight_size[d] - 1) + 1;
output_size[d] = (input_size[d] + (2 * padding[d - 2])
- kernel) / stride[d - 2] + 1;
}
return output_size;
}
double
check_multiple( double * tgt, double * src, int & ind, IntList & nb, SeedList & seeds, double & tolerance, int & nx, int & ny ) {
if ( nb.size() == 1 ) return nb.front();
if ( nb.size() < 1 ) return 0.0; // dumb protection
double diff, maxdiff = 0.0, res = 0.0;
int i;
IntList::iterator it;
SeedList::iterator sit;
PointXY ptsit, pt = pointFromIndex( ind, nx );
double distx, dist = FLT_MAX;
/* maxdiff */
for ( it = nb.begin(); it != nb.end(); it++ ) {
if ( !get_seed( seeds, *it, sit ) ) continue;
diff = fabs( src[ ind ] - src[ (*sit).index ] );
if ( diff > maxdiff ) {
maxdiff = diff;
/* assign result to the steepest until and if it not assigned to closest over the tolerance */
if ( dist == FLT_MAX )
res = *it;
}
/* we assign to the closest centre which is above tolerance, if none than to maxdiff */
if ( diff >= tolerance ) {
ptsit = pointFromIndex( (*sit).index, nx );
distx = distanceXY( pt, ptsit);
if ( distx < dist ) {
dist = distx;
res = * it;
}
}
}
/* assign all that need assignment to res, which has maxdiff */
for ( it = nb.begin(); it != nb.end(); it++ ) {
if ( *it == res ) continue;
if ( !get_seed( seeds, *it, sit ) ) continue;
if ( fabs( src[ ind ] - src[ (*sit).index ] ) >= tolerance ) continue;
for ( i = 0; i < nx * ny; i++ )
if ( tgt[ i ] == *it )
tgt[ i ] = res;
seeds.erase( sit );
}
return res;
}
static bool compare(const IntList& flist, const std::list<int>& l)
{
if (flist.size() == l.size())
{
IntList::ConstElementHandler h(flist.first());
std::list<int>::const_iterator it = l.begin();
bool equals = true;
while (h.is_valid() && equals)
{
equals = *h == *it;
++h;
++it;
}
return equals;
}
else
{
return false;
}
}
static PyObject * THPVariable_stride(PyObject* self, PyObject* args, PyObject* kwargs)
{
HANDLE_TH_ERRORS
static PythonArgParser parser({
"stride(int64_t dim)",
"stride()",
});
auto& self_ = reinterpret_cast<THPVariable*>(self)->cdata;
ParsedArgs<3> parsed_args;
auto r = parser.parse(args, kwargs, parsed_args);
if (r.idx == 0) {
return wrap(self_.stride(r.toInt64(0)));
} else if (r.idx == 1) {
// yes, this is called strides in ATen.
IntList strides = self_.strides();
// we can't do the normal wrapping here because IntList maps to both
// torch.Size and tuple in python
return THPUtils_packInt64Array(strides.size(), strides.data());
}
Py_RETURN_NONE;
END_HANDLE_TH_ERRORS
}
int *flattenIVecList(int t, int vecDim, IntVecList* pintVecList)
{
int szvec = 0;
int *array = NULL;
// walk through the vector list and check few things then send the packed version
int *p = NULL;
if (NULL == pintVecList)
return 0;
for(int i=0; i<(int)pintVecList->size(); i++)
{
if(szvec == 0) {
szvec = (int)((*pintVecList)[i]->size());
p = array = new int[szvec * pintVecList->size()]; // we assume all vectors are the same size
}
else if(szvec != (*pintVecList)[i]->size()) {
yyerror("Vector list has inconsistent vectors\n");
continue;
}
IntList* pfl = (*pintVecList)[i];
if (NULL!=pfl)
{
for(int j=0; j<(int)pfl->size(); j++)
*p++ = (*pfl)[j];
delete pfl;
pfl = NULL;
}
}
if(vecDim < 0)
vecDim = (int)pintVecList->size();
// we do the test here in any case : the previous loop needed to do some "delete" anyways
if((szvec != vecDim) || (t != pintVecList->size()))
{
yyerror("Vector dimension in value assignment don't match the type\n");
delete array;
return NULL;
}
return array;
}
static void recursive_store(char* data, IntList sizes, IntList strides, int64_t dim,
ScalarType scalarType, int elementSize, PyObject* obj) {
int64_t ndim = sizes.size();
if (dim == ndim) {
torch::utils::store_scalar(data, scalarType, obj);
return;
}
auto n = sizes[dim];
auto seq = THPObjectPtr(PySequence_Fast(obj, "not a sequence"));
if (!seq) throw python_error();
auto seq_size = PySequence_Fast_GET_SIZE(seq.get());
if (seq_size != n) {
throw ValueError("expected sequence of length %lld at dim %lld (got %lld)",
(long long)n, (long long)dim, (long long)seq_size);
}
PyObject** items = PySequence_Fast_ITEMS(seq.get());
for (int64_t i = 0; i < n; i++) {
recursive_store(data, sizes, strides, dim + 1, scalarType, elementSize, items[i]);
data += strides[dim] * elementSize;
}
}
// Given a list of lists of possible cage values:
// [[1,2,3], [3,4,5]]
// Recursively generates tuples of combinations from each of the lists as
// follows:
// [1,3]
// [1,4]
// [1,5]
// [2,3]
// [2,4]
// ... etc
// Each of these is checked against the target sum, and pushed into a result
// vector if they match.
// Note: The algorithm assumes that the list of possibles/candidates are
// ordered. This allows it to bail out early if it detects there's no point
// going further.
static void subsetSum(const std::vector<IntList> &possible_lists,
const std::size_t p_size, IntList &tuple,
unsigned tuple_sum, std::vector<IntList> &subsets,
const unsigned target_sum, unsigned list_idx) {
for (unsigned p = list_idx; p < p_size; ++p) {
for (auto &poss : possible_lists[p]) {
// Optimization for small target sums: if the candidate is bigger than
// the target itself then it can't be valid, neither can any candidate
// after it (ordered).
if (target_sum < static_cast<unsigned>(poss)) {
break;
}
// Can't repeat a value inside a cage
if (std::find(tuple.begin(), tuple.end(), poss) != tuple.end()) {
continue;
}
// Pre-calculate the new tuple values to avoid spurious
// insertions/deletions to the vector.
const auto new_tuple_sum = tuple_sum + poss;
const auto new_tuple_size = tuple.size() + 1;
// If we've added too much then we can bail out (ordered).
if (new_tuple_sum > target_sum) {
break;
}
// If there are fewer spots left in the tuple than there are options for
// the sum to reach the target, bail.
// TODO: This could be more sophisticated (can't have more than one 1, so
// it's more like the N-1 sum that it should be greater than.
if ((p_size - new_tuple_size) > (target_sum - new_tuple_sum)) {
break;
}
if (new_tuple_size == p_size) {
// If we've reached our target size then we can stop searching other
// possiblities from this list (ordered).
if (new_tuple_sum == target_sum) {
tuple.push_back(poss);
subsets.push_back(tuple);
tuple.pop_back();
break;
}
// Else, move on to the next candidate in the list.
continue;
}
tuple_sum += poss;
tuple.push_back(poss);
subsetSum(possible_lists, p_size, tuple, tuple_sum, subsets, target_sum,
p + 1);
tuple.pop_back();
tuple_sum -= poss;
}
}
}
TEST_EQUAL(sv[2], " maybe")
std::vector<double> dv = ListUtils::create<double>("1.2,3.5");
TEST_EQUAL(dv.size(), 2)
ABORT_IF(dv.size() != 2)
TEST_EQUAL(dv[0], 1.2)
TEST_EQUAL(dv[1], 3.5)
std::vector<Int> iv = ListUtils::create<Int>("1,5");
TEST_EQUAL(iv.size(),2)
ABORT_IF(iv.size() != 2)
TEST_EQUAL(iv[0], 1)
TEST_EQUAL(iv[1], 5)
IntList iv2 = ListUtils::create<Int>("2");
TEST_EQUAL(iv2.size(),1)
TEST_EQUAL(iv2[0],2)
IntList iv3 = ListUtils::create<Int>("");
TEST_EQUAL(iv3.size(),0)
StringList sl1 = ListUtils::create<String>("test string,string2,last string");
TEST_EQUAL(sl1.size(),3)
ABORT_IF(sl1.size() != 3)
TEST_EQUAL(sl1[0], "test string")
TEST_EQUAL(sl1[1], "string2")
TEST_EQUAL(sl1[2], "last string")
StringList list = ListUtils::create<String>("yes,no");
TEST_EQUAL(list.size(),2)
ABORT_IF(list.size() != 2)
TEST_EQUAL(list[0],"a")
TEST_EQUAL(list[1],"bb")
TEST_EQUAL(list[2],"ccc")
TEST_EQUAL(p2.getValue("stringlist2").valueType(), DataValue::STRING_LIST)
list = p2.getValue("stringlist2");
TEST_EQUAL(list.size(),0)
TEST_EQUAL(p2.getValue("stringlist").valueType(), DataValue::STRING_LIST)
list = p2.getValue("stringlist3");
TEST_EQUAL(list.size(),1)
TEST_EQUAL(list[0],"1")
TEST_EQUAL(p2.getValue("intlist").valueType(), DataValue::INT_LIST)
IntList intlist = p2.getValue("intlist");
TEST_EQUAL(intlist.size(),3);
TEST_EQUAL(intlist[0], 1)
TEST_EQUAL(intlist[1], 22)
TEST_EQUAL(intlist[2], 333)
TEST_EQUAL(p2.getValue("intlist2").valueType(),DataValue::INT_LIST)
intlist = p2.getValue("intlist2");
TEST_EQUAL(intlist.size(),0)
TEST_EQUAL(p2.getValue("intlist3").valueType(),DataValue::INT_LIST)
intlist = p2.getValue("intlist3");
TEST_EQUAL(intlist.size(),1)
TEST_EQUAL(intlist[0],1)
TEST_EQUAL(p2.getValue("doublelist").valueType(), DataValue::DOUBLE_LIST)
DoubleList doublelist = p2.getValue("doublelist");
/*----------------------------------------------------------------------- */
SEXP
watershed (SEXP x, SEXP _tolerance, SEXP _ext) {
SEXP res;
int im, i, j, nx, ny, nz, ext, nprotect = 0;
double tolerance;
nx = INTEGER ( GET_DIM(x) )[0];
ny = INTEGER ( GET_DIM(x) )[1];
nz = getNumberOfFrames(x,0);
tolerance = REAL( _tolerance )[0];
ext = INTEGER( _ext )[0];
PROTECT ( res = Rf_duplicate(x) );
nprotect++;
int * index = new int[ nx * ny ];
for ( im = 0; im < nz; im++ ) {
double * src = &( REAL(x)[ im * nx * ny ] );
double * tgt = &( REAL(res)[ im * nx * ny ] );
/* generate pixel index and negate the image -- filling wells */
for ( i = 0; i < nx * ny; i++ ) {
tgt[ i ] = -src[ i ];
index[ i ] = i;
}
/* from R includes R_ext/Utils.h */
/* will resort tgt as well */
rsort_with_index( tgt, index, nx * ny );
/* reassign tgt as it was reset above but keep new index */
for ( i = 0; i < nx * ny; i++ )
tgt[ i ] = -src[ i ];
SeedList seeds; /* indexes of all seed starting points, i.e. lowest values */
IntList equals; /* queue of all pixels on the same gray level */
IntList nb; /* seed values of assigned neighbours */
int ind, indxy, nbseed, x, y, topseed = 0;
IntList::iterator it;
TheSeed newseed;
PointXY pt;
bool isin;
/* loop through the sorted index */
for ( i = 0; i < nx * ny && src[ index[i] ] > BG; ) {
/* pool a queue of equally lowest values */
ind = index[ i ];
equals.push_back( ind );
for ( i = i + 1; i < nx * ny; ) {
if ( src[ index[i] ] != src[ ind ] ) break;
equals.push_back( index[i] );
i++;
}
while ( !equals.empty() ) {
/* first check through all the pixels if we can assign them to
* existing objects, count checked and reset counter on each assigned
* -- exit when counter equals queue length */
for ( j = 0; j < (int) equals.size(); ) {
if ((j%1000)==0) R_CheckUserInterrupt();
ind = equals.front();
equals.pop_front();
/* check neighbours:
* - if exists one, assign
* - if two or more check what should be combined and assign to the steepest
* - if none, push back */
/* reset j to 0 every time we assign another pixel to restart the loop */
nb.clear();
pt = pointFromIndex( ind, nx );
/* determine which neighbour we have, push them to nb */
for ( x = pt.x - ext; x <= pt.x + ext; x++ )
for ( y = pt.y - ext; y <= pt.y + ext; y++ ) {
if ( x < 0 || y < 0 || x >= nx || y >= ny || (x == pt.x && y == pt.y) ) continue;
indxy = x + y * nx;
nbseed = (int) tgt[ indxy ];
if ( nbseed < 1 ) continue;
isin = false;
for ( it = nb.begin(); it != nb.end() && !isin; it++ )
if ( nbseed == *it ) isin = true;
if ( !isin ) nb.push_back( nbseed );
}
if ( nb.size() == 0 ) {
/* push the pixel back and continue with the next one */
equals.push_back( ind );
j++;
continue;
}
tgt[ ind ] = check_multiple(tgt, src, ind, nb, seeds, tolerance, nx, ny );
/* we assigned the pixel, reset j to restart neighbours detection */
j = 0;
}
/* now we have assigned all that we could */
if ( !equals.empty() ) {
/* create a new seed for one pixel only and go back to assigning neighbours */
topseed++;
newseed.index = equals.front();
newseed.seed = topseed;
equals.pop_front();
tgt[ newseed.index ] = topseed;
seeds.push_back( newseed );
}
} // assigning equals
} // sorted index
/* now we need to reassign indexes while some seeds could be removed */
double * finseed = new double[ topseed ];
for ( i = 0; i < topseed; i++ )
finseed[ i ] = 0;
i = 0;
while ( !seeds.empty() ) {
newseed = seeds.front();
seeds.pop_front();
finseed[ newseed.seed - 1 ] = i + 1;
i++;
}
for ( i = 0; i < nx * ny; i++ ) {
j = (int) tgt[ i ];
if ( 0 < j && j <= topseed )
tgt[ i ] = finseed[ j - 1 ];
}
delete[] finseed;
} // loop through images
delete[] index;
UNPROTECT (nprotect);
return res;
}