Source code for honeybee_plus.radiance.command.rmtxop

# coding=utf-8
from ._commandbase import RadianceCommand
from ..datatype import RadiancePath, RadianceTuple, RadianceBoolFlag
from ..parameters.rmtxop import RmtxopParameters
from ... import config
import os


[docs]class RmtxopMatrix(RadianceCommand): transpose = RadianceBoolFlag('t', 'transpose the matrix') scalar_factors = RadianceTuple('s', 'scalar values for elements') transform_coefficients = RadianceTuple('c', 'transformation coefficients') matrix_file = RadiancePath('input_matrixFile', 'input matrix file.') def __init__(self, transpose=None, scalar_factors=None, transform_coefficients=None, matrix_file=None): RadianceCommand.__init__(self, 'rmtxop') self.transpose = transpose """Set this to true to transpose the matrix""" self.scalar_factors = scalar_factors """Scalar values for resizing the elements of the matrix. If a single value is specified then it will be applied across the board.""" self.transform_coefficients = transform_coefficients self.matrix_file = matrix_file # Overriding these properties as I don't want the script to check for # binaries named PcombImage in radbin ! @property def radbin_path(self): """Get and set path to radiance binaries. If you set a new value the value will be changed globally. """ return config.radbin_path @radbin_path.setter def radbin_path(self, path): # change the path in config so user need to set it up once in a single # script config.radbin_path = path
[docs] def to_rad_string(self, relative_path=False): transpose = self.transpose.to_rad_string() scl_fact = self.scalar_factors.to_rad_string() transform = self.transform_coefficients.to_rad_string() mtx = self.matrix_file.to_rad_string() rad_string = "{} {} {} {}".format(transpose, scl_fact, transform, mtx) return rad_string
@property def input_files(self): return self.matrix_file.to_rad_string()
[docs] def execute(self): raise Exception('The class RmtxopMatrix cannot be executed on its own.' 'It is only meant to create matrix classes for Rmtxop.')
[docs]class Rmtxop(RadianceCommand): """ rmtxop - concatenate, add, transpose, scale, and convert matrices rmtxop [ -v ][ -f[afdc] ][ -t ][ -s sf .. ][ -c ce .. ] m1 [ + ] .. #Simple usage (for just adding stuff): mtx = Rmtxop() mtx.matrix_files = [matrix_filePath1, matrix_filePath2] mtx.output_file = output_matrixFilePath #Then to_rad_string will be: 'rmtxop matrix_filesPath1 + matrix_filePath2 > output_matrixFilePath' #Advanced usage with transformations and such. In this case I am subtracting one # matrix and adding another. final_matrix = Rmtxop() #std. dc matrix. dc_matrix = RmtxopMatrix() dc_matrix.matrix_file = x.ill #direct dc matrix. -1 indicates that this one is being subtracted from dc matrix. dc_direct_matrix = RmtxopMatrix() dc_direct_matrix.matrix_file = y.ill dc_direct_matrix.scalar_factors = [-1] #Sun coefficient matrix. sun_coeff_matrix = RmtxopMatrix() sun_coeff_matrix.matrix_file = z.ill #combine the matrices together. Sequence is extremely important final_matrix.rmtxop_matrices = [dc_matrix,dc_direct_matrix,sun_coeff_matrix] final_matrix.output_file = res.ill #Then the to_rad_string will be: c:/radiance/bin/rmtxop x.ill + -s -1 y.ill + z.ill > res.ill """ output_file = RadiancePath('output_file', descriptive_name='output matrix file', relative_path=None, check_exists=False) def __init__(self, matrix_files=None, rmtxop_matrices=None, output_file=None, rmtxop_parameters=None): RadianceCommand.__init__(self) self.matrix_files = matrix_files self.output_file = output_file self.rmtxop_parameters = rmtxop_parameters self.rmtxop_matrices = rmtxop_matrices @property def rmtxop_parameters(self): """Get and set rmtxop_parameters.""" return self.__rmtxop_parameters @rmtxop_parameters.setter def rmtxop_parameters(self, rmtxop_param): self.__rmtxop_parameters = rmtxop_param if rmtxop_param is not None \ else RmtxopParameters() assert hasattr(self.rmtxop_parameters, "isRadianceParameters"), \ "input rmtxop_parameters is not a valid parameters type." @property def rmtxop_matrices(self): return self.__rmtxop_matrices @rmtxop_matrices.setter def rmtxop_matrices(self, rmtxop_matrices): if rmtxop_matrices: if isinstance(rmtxop_matrices, RmtxopMatrix): self.__rmtxop_matrices = [rmtxop_matrices] else: try: self.__rmtxop_matrices = [] for idx, matrix in enumerate(rmtxop_matrices): assert isinstance(matrix, RmtxopMatrix), \ 'The input #%s is not an RmtxopMatrix' % idx self.__rmtxop_matrices.append(matrix) except Exception: raise Exception( "The input for rmtxop_matrices should either be an instance" "of the class RmtxopMatrix or a list/tuple/iterable containing" " multiple instances of the RmtxopMatrix.") else: self.__rmtxop_matrices = None @property def matrix_files(self): """Get and set scene files.""" return self.__matrix_files @matrix_files.setter def matrix_files(self, files): if files: self.__matrix_files = [os.path.normpath(str(f)) for f in files] else: self.__matrix_files = None
[docs] def to_rad_string(self, relative_path=False): """Return full command as string.""" # If matrices are complex .i.e containing transformations scalars etc., get to # them first. compound_matrices = '' if self.rmtxop_matrices: matrices = [matrix.to_rad_string() for matrix in self.rmtxop_matrices] compound_matrices = " + ".join(matrices) # This are just plain matrix files..for simple addition. matrix_files = '' if self.matrix_files: matrix_files = " + ".join(self.matrix_files) # If compound matrices have already been specified, then add a plus in # the beginning. if compound_matrices: matrix_files = "+ %s" % matrix_files rad_string = "%s %s %s %s > %s" % ( self.normspace(os.path.join(self.radbin_path, 'rmtxop')), self.rmtxop_parameters.to_rad_string(), compound_matrices, matrix_files, self.normspace(self.output_file.to_rad_string()) ) return ' '.join(rad_string.split())
@property def input_files(self): """Input files. For this command are actually None as the files are specified as inputs using the matrices input """ return self.matrix_files