transform_coordinates()

std::vector< uint64_t > MayaFlux::Kakshya::transform_coordinates	(	const std::vector< uint64_t > &	coords,
		const std::vector< double > &	scale_factors = {},
		const std::vector< int64_t > &	offset_values = {},
		const std::unordered_map< std::string, std::any > &	rotation_params = {}
	)

Transform coordinates using scaling, translation, rotation.

Parameters

coords	Input coordinates.
scale_factors	Scaling factors per dimension.
offset_values	Translation offset per dimension.
rotation_params	Optional rotation parameters.

Returns

Transformed coordinates.

Definition at line 80 of file CoordUtils.cpp.

{
    std::vector<uint64_t> transformed = coords;
 
    if (!scale_factors.empty()) {
        for (size_t i = 0; i < coords.size() && i < scale_factors.size(); ++i) {
            transformed[i] = static_cast<uint64_t>(scale_factors[i] * static_cast<double>(coords[i]));
        }
    }
 
    if (!offset_values.empty()) {
        for (size_t i = 0; i < transformed.size() && i < offset_values.size(); ++i) {
            int64_t new_coord = static_cast<int64_t>(transformed[i]) + offset_values[i];
            transformed[i] = static_cast<uint64_t>(std::max(int64_t(0), new_coord));
        }
    }
 
    if (!rotation_params.empty() && coords.size() >= 2) {
        auto angle_it = rotation_params.find("angle_radians");
        if (angle_it != rotation_params.end()) {
            try {
                auto angle = safe_any_cast_or_throw<double>(angle_it->second);
                double cos_a = std::cos(angle);
                double sin_a = std::sin(angle);
 
                auto x = static_cast<double>(transformed[0]);
                auto y = static_cast<double>(transformed[1]);
 
                transformed[0] = static_cast<uint64_t>(x * cos_a - y * sin_a);
                transformed[1] = static_cast<uint64_t>(x * sin_a + y * cos_a);
            } catch (const std::bad_any_cast&) {
                // TODO: DO better than ignore invalid
            }
        }
    }
 
    return transformed;
}