minterval.hh

Go to the documentation of this file.

/*
* This file is part of rasdaman community.
*
* Rasdaman community is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Rasdaman community is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with rasdaman community.  If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
rasdaman GmbH.
*
* For more information please see <http://www.rasdaman.org>
* or contact Peter Baumann via <baumann@rasdaman.com>.
*/
 
#ifndef D_MINTERVAL_HH
#define D_MINTERVAL_HH
 
#include "raslib/sinterval.hh"
#include "raslib/point.hh"
#include "raslib/mddtypes.hh"  // for r_Dimension, r_Area, r_Bytes, r_Range
 
#include <iosfwd>  // for ostream, cout
#include <string>  // for string
#include <vector>  // for vector
 
//@ManMemo: Module: {\bf raslib}
class r_Minterval
{
public:
    using DimType = r_Dimension;
    using AreaType = r_Area;
    using OffsetType = r_Sinterval::OffsetType;
 
    r_Minterval(const r_Point &low, const r_Point &high);
    explicit r_Minterval(r_Dimension);
    explicit r_Minterval(const char *);
    explicit r_Minterval(char *);
    explicit r_Minterval(std::vector<r_Sinterval> intervals);
    r_Minterval &operator<<(const r_Sinterval &);
    r_Minterval &operator<<(r_Range);
    static r_Minterval fromPoint(const r_Point &p);
 
    r_Minterval() = default;
    ~r_Minterval() = default;
 
    r_Minterval(r_Minterval &&other) = default;
    r_Minterval &operator=(r_Minterval &&other) = default;
 
    r_Minterval(const r_Minterval &other) = default;
    r_Minterval &operator=(const r_Minterval &other) = default;
 
    const r_Sinterval &operator[](r_Dimension) const;
 
    const r_Sinterval &at(r_Dimension) const;
 
    r_Sinterval &operator[](r_Dimension);
 
    r_Sinterval &at(r_Dimension);
 
    const r_Sinterval &at_unsafe(r_Dimension dim) const;
    r_Sinterval &at_unsafe(r_Dimension dim);
 
    bool operator==(const r_Minterval &) const;
 
    bool operator!=(const r_Minterval &) const;
 
    bool equal_extents(const r_Minterval &other) const;
 
    bool covers(const r_Point &pnt) const;
 
    bool covers(const r_Minterval &inter) const;
 
    bool inside_of(const r_Minterval &) const;
 
    std::vector<r_Minterval> split_equal(int n);
 
    r_Dimension dimension() const;
 
    bool is_scalar() const noexcept;
 
    r_Point get_origin() const;
 
    r_Point get_high() const;
 
    r_Point get_extent() const;
 
    bool is_origin_fixed() const noexcept;
 
    bool is_high_fixed() const noexcept;
 
    bool is_fixed() const noexcept;
 
    std::vector<std::string> get_axis_names() const;
 
    void set_axis_names(std::vector<std::string> axis_names);
 
    void set_axis_names(const r_Minterval &o);
 
    bool axis_names_match(const r_Minterval &o) const;
 
    bool has_axis_names() const;
 
    bool is_mergeable(const r_Minterval &other) const;
 
    // Methods for translation:
 
    r_Minterval &reverse_translate(const r_Point &);
 
    r_Minterval create_reverse_translation(const r_Point &) const;
 
    r_Minterval &translate(const r_Point &);
 
    r_Minterval create_translation(const r_Point &) const;
 
    // Methods for scaling:
 
    r_Minterval &scale(const double &);
    r_Minterval &scale(const std::vector<double> &);
    r_Minterval create_scale(const double &) const;
    r_Minterval create_scale(const std::vector<double> &) const;
    std::vector<double> scale_of(const r_Minterval &op) const;
 
    // Methods/Operators for the union operation:
 
    r_Minterval &union_of(const r_Minterval &, const r_Minterval &);
    r_Minterval &union_with(const r_Minterval &);
    r_Minterval &operator+=(const r_Minterval &);
    r_Minterval create_union(const r_Minterval &) const;
    r_Minterval operator+(const r_Minterval &) const;
 
    // Methods/Operators for the difference operation:
 
    r_Minterval &difference_of(const r_Minterval &, const r_Minterval &);
    r_Minterval &difference_with(const r_Minterval &);
    r_Minterval &operator-=(const r_Minterval &);
    r_Minterval create_difference(const r_Minterval &) const;
    r_Minterval operator-(const r_Minterval &) const;
 
    // Methods/Operators for the intersection operation:
 
    r_Minterval &intersection_of(const r_Minterval &, const r_Minterval &);
    r_Minterval &intersection_with(const r_Minterval &);
    r_Minterval &operator*=(const r_Minterval &);
    r_Minterval create_intersection(const r_Minterval &) const;
    r_Minterval operator*(const r_Minterval &) const;
    bool intersects_with(const r_Minterval &) const;
    bool touches(const r_Minterval &o) const;
 
    // Methods/Operators for the closure operation:
 
    r_Minterval &closure_of(const r_Minterval &, const r_Minterval &);
    r_Minterval &closure_with(const r_Minterval &);
    r_Minterval create_closure(const r_Minterval &) const;
    std::vector<r_Minterval> extension_of(const r_Minterval &big) const;
 
    // Methods/Operators for dimension-specific operations involving projections:
 
    r_Minterval trim_along_slice(const r_Minterval &, const std::vector<r_Dimension> &) const;
    r_Minterval project_along_dims(const std::vector<r_Dimension> &) const;
 
    void print_status(std::ostream &s) const;
 
    char *get_string_representation() const;
 
    std::string to_string() const;
 
    // Methods for internal use only:
 
    r_Area cell_count() const;
    r_Area cell_offset(const r_Point &) const;
    r_Area cell_offset_unsafe(const r_Point &) const;
    r_Point cell_point(r_Area) const;
 
    void add_dimension();
    void delete_dimension(r_Dimension);
    void swap_dimensions(r_Dimension d1, r_Dimension d2);
    void delete_non_trims(const std::vector<bool> &trims);
    void delete_slices();
    void append_axes(const r_Minterval &mint);
    void append_axes(const r_Point &pnt);
    bool is_point() const noexcept;
 
    r_Bytes get_storage_size() const;
 
    r_Dimension get_trim_count() const;
 
    bool has_slices() const;
 
    bool compareDomainExtents(const r_Minterval &b) const;
    void validateDomainExtents(const r_Minterval &b) const;
 
    r_Minterval computeDomainOfResult(const r_Minterval &b) const;
 
protected:
    std::vector<r_Sinterval> intervals;
 
    r_Dimension streamInitCnt{};
 
    void constructorinit(char *);
};
 
//@ManMemo: Module: {\bf raslib}
extern std::ostream &operator<<(std::ostream &s, const r_Minterval &d);
extern std::ostream &operator<<(std::ostream &s, const std::vector<r_Minterval> &d);
extern std::ostream &operator<<(std::ostream &s, const std::vector<double> &doubleVec);
 
#endif