C++ Coordinates::y方法代码示例

		const Coordinates to_chunk_coordinates(const Coordinates& c)
		{
			int x = ((int)std::floor(c.x() / (double)NM_CHUNK_SIZE));
			int y = ((int)std::floor(c.y() / (double)NM_CHUNK_SIZE));

			return {x, y};
		}

SimpleTensor<T> median3x3(const SimpleTensor<T> &src, BorderMode border_mode, T constant_border_value)
{
    SimpleTensor<T> dst(src.shape(), src.data_type());
    const int       size_tot_filter = filter_size * filter_size;

    for(int src_idx = 0; src_idx < src.num_elements(); ++src_idx)
    {
        std::array<T, size_tot_filter> filter_elems = { { 0 } };
        Coordinates id = index2coord(src.shape(), src_idx);
        const int   x  = id.x();
        const int   y  = id.y();

        for(int j = y - static_cast<int>(border_size.top), index = 0; j <= y + static_cast<int>(border_size.bottom); ++j)
        {
            for(int i = x - static_cast<int>(border_size.left); i <= x + static_cast<int>(border_size.right); ++i, ++index)
            {
                id.set(0, i);
                id.set(1, j);
                filter_elems[index] = tensor_elem_at(src, id, border_mode, constant_border_value);
            }
        }
        std::sort(filter_elems.begin(), filter_elems.end());
        dst[src_idx] = filter_elems[size_tot_filter / 2];
    }

    return dst;
}

bool Bishop::MayIGoHere(Coordinates position, Coordinates prev_position, QPointer<Player> friends, QPointer<Player>& enemies, bool CheckForCheck/* = true*/)
{
    if ((prev_position.y() - prev_position.x() != position.y() - position.x()) &&
            (prev_position.y() + prev_position.x() != position.y() + position.x()))
        return false;

    QPointer<Piece> pieceForDelete;
    for (int x = position.x(), y = position.y(); x != prev_position.x(), y != prev_position.y(); (position.x() < prev_position.x())?++x:--x, (position.y() < prev_position.y())?++y:--y)
    {
        if (!(friends->GetAnotherPiece(Coordinates(x, y), this).isNull()))
            return false;
        QPointer<Piece> piece = enemies->GetPiece(Coordinates(x, y));
        if (!piece.isNull())
        {
            if ((x == position.x()) && (y == position.y()))
                pieceForDelete = piece;
            else
            {
                pieceForDelete.clear();
                return false;
            }
        }
    }
    if (CheckForCheck)
    {
        if (enemies->MaySomebodyGoHere(friends->GetKing(), friends, pieceForDelete))
        {
            pieceForDelete.clear();
            return false;
        }
    }

    if (!pieceForDelete.isNull() && CheckForCheck)
        enemies->RemovePiece(pieceForDelete);

    pieceForDelete.clear();
    return true;
}

		const Coordinates to_global_coordinates(const Coordinates& local, const Coordinates& chunk)
		{
			return {local.x() + (NM_CHUNK_SIZE * chunk.x()), local.y() + (NM_CHUNK_SIZE * chunk.y())};
		}

SimpleTensor<T> warp_perspective(const SimpleTensor<T> &src, SimpleTensor<T> &valid_mask, const float *matrix, InterpolationPolicy policy, BorderMode border_mode, uint8_t constant_border_value)
{
    SimpleTensor<T> dst(src.shape(), src.data_type());

    // x0 = M00 * x + M01 * y + M02
    // y0 = M10 * x + M11 * y + M12
    // z0 = M20 * x + M21 * y + M22
    // xn = x0 / z0
    // yn = y0 / z0
    const float M00 = matrix[0];
    const float M10 = matrix[1];
    const float M20 = matrix[2];
    const float M01 = matrix[0 + 1 * 3];
    const float M11 = matrix[1 + 1 * 3];
    const float M21 = matrix[2 + 1 * 3];
    const float M02 = matrix[0 + 2 * 3];
    const float M12 = matrix[1 + 2 * 3];
    const float M22 = matrix[2 + 2 * 3];

    const int width  = src.shape().x();
    const int height = src.shape().y();

    for(int element_idx = 0; element_idx < src.num_elements(); ++element_idx)
    {
        valid_mask[element_idx] = 1;
        Coordinates id          = index2coord(src.shape(), element_idx);
        const int   idx         = id.x();
        const int   idy         = id.y();
        const float z0          = M20 * idx + M21 * idy + M22;

        const float x0 = (M00 * idx + M01 * idy + M02);
        const float y0 = (M10 * idx + M11 * idy + M12);

        const float xn = x0 / z0;
        const float yn = y0 / z0;
        id.set(0, static_cast<int>(std::floor(xn)));
        id.set(1, static_cast<int>(std::floor(yn)));
        if((0 <= yn) && (yn < height) && (0 <= xn) && (xn < width))
        {
            switch(policy)
            {
                case InterpolationPolicy::NEAREST_NEIGHBOR:
                    dst[element_idx] = tensor_elem_at(src, id, border_mode, constant_border_value);
                    break;
                case InterpolationPolicy::BILINEAR:
                    (valid_bilinear_policy(xn, yn, width, height, border_mode)) ? dst[element_idx] = bilinear_policy(src, id, xn, yn, border_mode, constant_border_value) : valid_mask[element_idx] = 0;
                    break;
                case InterpolationPolicy::AREA:
                default:
                    ARM_COMPUTE_ERROR("Interpolation not supported");
                    break;
            }
        }
        else
        {
            if(border_mode == BorderMode::UNDEFINED)
            {
                valid_mask[element_idx] = 0;
            }
            else
            {
                switch(policy)
                {
                    case InterpolationPolicy::NEAREST_NEIGHBOR:
                        if(border_mode == BorderMode::CONSTANT)
                        {
                            dst[element_idx] = constant_border_value;
                        }
                        else if(border_mode == BorderMode::REPLICATE)
                        {
                            id.set(0, std::max(0, std::min(static_cast<int>(xn), width - 1)));
                            id.set(1, std::max(0, std::min(static_cast<int>(yn), height - 1)));
                            dst[element_idx] = src[coord2index(src.shape(), id)];
                        }
                        break;
                    case InterpolationPolicy::BILINEAR:
                        dst[element_idx] = bilinear_policy(src, id, xn, yn, border_mode, constant_border_value);
                        break;
                    case InterpolationPolicy::AREA:
                    default:
                        ARM_COMPUTE_ERROR("Interpolation not supported");
                        break;
                }
            }
        }
    }
    return dst;
}

SimpleTensor<T> non_linear_filter(const SimpleTensor<T> &src, NonLinearFilterFunction function, unsigned int mask_size, MatrixPattern pattern, const uint8_t *mask, BorderMode border_mode,
                                  uint8_t constant_border_value)
{
    SimpleTensor<T> dst(src.shape(), src.data_type());

    ARM_COMPUTE_ERROR_ON(pattern == MatrixPattern::OTHER && mask == nullptr);
    ARM_COMPUTE_UNUSED(pattern);

    using intermediate_type = typename common_promoted_signed_type<T>::intermediate_type;

    const int                      sq_mask_size   = mask_size * mask_size;
    const int                      half_mask_size = mask_size / 2;
    std::vector<intermediate_type> vals(sq_mask_size);
    intermediate_type              current_value = 0;

    const ValidRegion valid_region = shape_to_valid_region(src.shape(), border_mode == BorderMode::UNDEFINED, BorderSize(half_mask_size));

    for(int element_idx = 0, count = 0, index = 0; element_idx < src.num_elements(); ++element_idx, count = 0, index = 0)
    {
        Coordinates id = index2coord(src.shape(), element_idx);
        if(is_in_valid_region(valid_region, id))
        {
            int idx = id.x();
            int idy = id.y();
            for(int y = idy - half_mask_size; y <= idy + half_mask_size; ++y)
            {
                for(int x = idx - half_mask_size; x <= idx + half_mask_size; ++x, ++index)
                {
                    id.set(0, x);
                    id.set(1, y);
                    current_value = tensor_elem_at(src, id, border_mode, constant_border_value);

                    if(mask[index] == 255)
                    {
                        vals[count] = static_cast<intermediate_type>(current_value);
                        ++count;
                    }
                }
            }
            std::sort(vals.begin(), vals.begin() + count);

            ARM_COMPUTE_ERROR_ON(count == 0);

            switch(function)
            {
                case NonLinearFilterFunction::MIN:
                    dst[element_idx] = saturate_cast<T>(vals[0]);
                    break;
                case NonLinearFilterFunction::MAX:
                    dst[element_idx] = saturate_cast<T>(vals[count - 1]);
                    break;
                case NonLinearFilterFunction::MEDIAN:
                    dst[element_idx] = saturate_cast<T>(vals[count / 2]);
                    break;
                default:
                    ARM_COMPUTE_ERROR("Unsupported NonLinearFilter function.");
            }
        }
    }

    return dst;
}

static const Coordinates min(const Coordinates &a, const Coordinates &b)
{
	return Coordinates(MIN(a.x(), b.x()), MIN(a.y(), b.y()));
}