KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use _flush method in localstack

Best Python code snippet using localstack_python

surrender_client.py

Source:surrender_client.py

...14        params["element_name"] = str(element_name);15        params["texture_name"] = str(texture_name);16        params["texture_unit_id"] = int(texture_unit_id);17        self._stream.writeQVariantHash(params);18        self._flush(True);19        if not self._async:20            ret = self._read_return("attachDynamicTexture");21    def cd(self, path):22        """23        | Change the current resource path.24        | This is similar to the 'cd' command on Linux.25        """26        self._check_connection();27        params = { "" : "cd"};28        params["path"] = str(path);29        self._stream.writeQVariantHash(params);30        self._flush(True);31        if not self._async:32            ret = self._read_return("cd");33    def clearMetadata(self):34        """35        | Resets the metadata table36        """37        self._check_connection();38        params = { "" : "clearMetadata"};39        self._stream.writeQVariantHash(params);40        self._flush(True);41        if not self._async:42            ret = self._read_return("clearMetadata");43    def createBRDF(self, name, filename, parameters):44        """45        | Create a BRDF object which can be referenced with the name 'name'.46        | The BRDF model is loaded from the SuMoL file 'filename' with the parameters in 'parameters'.47        """48        self._check_connection();49        params = { "" : "createBRDF"};50        params["name"] = str(name);51        params["filename"] = str(filename);52        params["parameters"] = parameters;53        self._stream.writeQVariantHash(params);54        self._flush(True);55        if not self._async:56            ret = self._read_return("createBRDF");57    def createBody(self, body_name, shape_name, brdf_name, textures):58        """59        | Create an object with the shape 'shape_name' and BRDF 'brdf_name'.60        | 'textures' contain the textures to be used for (in order):61        |  - diffuse map62        |  - specular map63        |  - emission map64        |  - normal map65        """66        self._check_connection();67        params = { "" : "createBody"};68        params["body_name"] = str(body_name);69        params["shape_name"] = str(shape_name);70        params["brdf_name"] = str(brdf_name);71        params["textures"] = textures;72        self._stream.writeQVariantHash(params);73        self._flush(True);74        if not self._async:75            ret = self._read_return("createBody");76    def createDEM(self, object_name, conemap_filename, brdf_name, texture):77        """78        | Create a DEM (Digital Elevation Model) from a '.dem' file. Displacement mapping is done from a plan.79        | The conemap can be built with the build_conemap tool.80        | 'texture' is the texture to be used for the diffuse texture map, empty means default white texture.81        """82        self._check_connection();83        params = { "" : "createDEM"};84        params["object_name"] = str(object_name);85        params["conemap_filename"] = str(conemap_filename);86        params["brdf_name"] = str(brdf_name);87        params["texture"] = str(texture);88        self._stream.writeQVariantHash(params);89        self._flush(True);90        ret = self._read_return("createDEM");91        return ret["info"]92    def createLight(self, light_name, spectrum, cutoff, exponent):93        """94        | Create a spot light.95        | 'spectrum' is the 4D spectrum of the light (in W for each wavelength simulated).96        | 'cutoff' is the maximum angle in degrees from the spot direction where the spot produce light.97        | 'exponent' controls how the power decreases when reaching the cutoff angle. 1 means linear, the higher the flatter it gets.98        """99        self._check_connection();100        params = { "" : "createLight"};101        params["light_name"] = str(light_name);102        params["spectrum"] = self._vec(spectrum);103        params["cutoff"] = float(cutoff);104        params["exponent"] = float(exponent);105        self._stream.writeQVariantHash(params);106        self._flush(True);107        if not self._async:108            ret = self._read_return("createLight");109    def createMesh(self, object_name, model_name, scale):110        """111        | Create a new mesh object in the scene.112        | 'object_name' is the name of the new object in the scene.113        | 'model_name' is the name of the model file.114        | 'scale' is the scaling factor to apply when loading the model (use 1 if the mesh is in meters, 1e-3 is it is in km, ...)115        """116        self._check_connection();117        params = { "" : "createMesh"};118        params["object_name"] = str(object_name);119        params["model_name"] = str(model_name);120        params["scale"] = float(scale);121        self._stream.writeQVariantHash(params);122        self._flush(True);123        if not self._async:124            ret = self._read_return("createMesh");125    def createPerPixelProcess(self, name, filename, parameters):126        """127        | Create a PerPixelProcess object for a SuMoL file and a set of parameters.128        | 'name' is used to reference the created object.129        | 130        """131        self._check_connection();132        params = { "" : "createPerPixelProcess"};133        params["name"] = str(name);134        params["filename"] = str(filename);135        params["parameters"] = parameters;136        self._stream.writeQVariantHash(params);137        self._flush(True);138        if not self._async:139            ret = self._read_return("createPerPixelProcess");140    def createShape(self, name, filename, parameters):141        """142        | Create a Shape object which can be referenced with the name 'name'.143        | The shape model is loaded from the SuMoL file 'filename' with the parameters in 'parameters'.144        """145        self._check_connection();146        params = { "" : "createShape"};147        params["name"] = str(name);148        params["filename"] = str(filename);149        params["parameters"] = parameters;150        self._stream.writeQVariantHash(params);151        self._flush(True);152        if not self._async:153            ret = self._read_return("createShape");154    def createSphericalDEM(self, object_name, conemap_filename, brdf_name, texture):155        """156        | Create a DEM (Digital Elevation Model) from a '.dem' file. Displacement mapping is done from the spherical body described in the DEM/PDS file.157        | The conemap can be built with the build_conemap tool.158        | 'texture' is the texture to be used for the diffuse texture map, empty means default white texture.159        """160        self._check_connection();161        params = { "" : "createSphericalDEM"};162        params["object_name"] = str(object_name);163        params["conemap_filename"] = str(conemap_filename);164        params["brdf_name"] = str(brdf_name);165        params["texture"] = str(texture);166        self._stream.writeQVariantHash(params);167        self._flush(True);168        ret = self._read_return("createSphericalDEM");169        return ret["info"]170    def createUserDataTexture(self, name, width, height, gray):171        """172        | Create a data texture whose content has to be provided by the client.173        | If 'gray' is true, the texture type is Y32F (single channel, float).174        | If 'gray' is false, the texture type is RGBA32F (4 channels, float).175        """176        self._check_connection();177        params = { "" : "createUserDataTexture"};178        params["name"] = str(name);179        params["width"] = int(width);180        params["height"] = int(height);181        params["gray"] = bool(gray);182        self._stream.writeQVariantHash(params);183        self._flush(True);184        if not self._async:185            ret = self._read_return("createUserDataTexture");186    def createVideoTexture(self, name, filename, loop):187        """188        | Create a new dynamic texture from a video.189        | If 'loop' is true, the video loops indefinitely, otherwise it stops at the last frame.190        """191        self._check_connection();192        params = { "" : "createVideoTexture"};193        params["name"] = str(name);194        params["filename"] = str(filename);195        params["loop"] = bool(loop);196        self._stream.writeQVariantHash(params);197        self._flush(True);198        if not self._async:199            ret = self._read_return("createVideoTexture");200    def dumpPhotonMapToFile(self, object_name, filename):201        """202        | Dump the photon map of an object to a PLY file.203        """204        self._check_connection();205        params = { "" : "dumpPhotonMapToFile"};206        params["object_name"] = str(object_name);207        params["filename"] = str(filename);208        self._stream.writeQVariantHash(params);209        self._flush(True);210        if not self._async:211            ret = self._read_return("dumpPhotonMapToFile");212    def enableAutoUpdate(self, enable):213        """214        | Enable (true) or disable (false) automatic update of viewer window after rendering.215        | Default: enabled216        """217        self._check_connection();218        params = { "" : "enableAutoUpdate"};219        params["enable"] = bool(enable);220        self._stream.writeQVariantHash(params);221        self._flush(True);222        if not self._async:223            ret = self._read_return("enableAutoUpdate");224    def enableDoublePrecisionMode(self, *args, **kwargs):225        """226        | This function is deprecated and has been removed!227        | It has been replaced with a stub function to avoid legacy script failures.228        """229        self._check_connection();230        params = { "" : "enableDoublePrecisionMode"};231        self._stream.writeQVariantHash(params);232        self._flush(True);233        self._read_return("enableDoublePrecisionMode");234        return None;235    def enableFastPSFMode(self, *args, **kwargs):236        """237        | This function is deprecated and has been removed!238        | It has been replaced with a stub function to avoid legacy script failures.239        """240        self._check_connection();241        params = { "" : "enableFastPSFMode"};242        self._stream.writeQVariantHash(params);243        self._flush(True);244        self._read_return("enableFastPSFMode");245        return None;246    def enableGlobalDynamicShadowMap(self, enable):247        """248        | If true, create a dynamic shadow map to compute sun visibility when rendering all objects249        | This shadow map is global, ie. adapted to exterior environments such as rover simulations or close range rendez-vous.250        | It overrides per object shadow maps.251        | If false, restore the default behavior with per object shadow maps.252        """253        self._check_connection();254        params = { "" : "enableGlobalDynamicShadowMap"};255        params["enable"] = bool(enable);256        self._stream.writeQVariantHash(params);257        self._flush(True);258        if not self._async:259            ret = self._read_return("enableGlobalDynamicShadowMap");260    def enableIrradianceMode(self, enable):261        """262        | Enable (true) or disable (false) irradiance mode.263        """264        self._check_connection();265        params = { "" : "enableIrradianceMode"};266        params["enable"] = bool(enable);267        self._stream.writeQVariantHash(params);268        self._flush(True);269        if not self._async:270            ret = self._read_return("enableIrradianceMode");271    def enableLOSmapping(self, b_enable):272        """273        | enable or disable LOS mapping274        | If true, LOS map will be allocated on image generation. Otherwise it is destroyed if one was allocated before.275        | LOS mapping only works in raytracing (in OpenGL you can deduce it from the pinhole model)276        """277        self._check_connection();278        params = { "" : "enableLOSmapping"};279        params["b_enable"] = bool(b_enable);280        self._stream.writeQVariantHash(params);281        self._flush(True);282        if not self._async:283            ret = self._read_return("enableLOSmapping");284    def enableMultilateralFiltering(self, *args, **kwargs):285        """286        | This function is deprecated and has been removed!287        | It has been replaced with a stub function to avoid legacy script failures.288        """289        self._check_connection();290        params = { "" : "enableMultilateralFiltering"};291        self._stream.writeQVariantHash(params);292        self._flush(True);293        self._read_return("enableMultilateralFiltering");294        return None;295    def enablePathTracing(self, enable):296        """297        | Enable (true) or disable (false) pathtracing.298        | Pathtracing requires raytracing to be enabled.299        """300        self._check_connection();301        params = { "" : "enablePathTracing"};302        params["enable"] = bool(enable);303        self._stream.writeQVariantHash(params);304        self._flush(True);305        if not self._async:306            ret = self._read_return("enablePathTracing");307    def enablePhotonAccumulation(self, enable):308        """309        | Enable (true) or disable (false) photon accumulation mode (Raytracing only).310        | Objects with the photon_map property set to true will be mapped with the energy received.311        | No image will be renderer in this mode!312        """313        self._check_connection();314        params = { "" : "enablePhotonAccumulation"};315        params["enable"] = bool(enable);316        self._stream.writeQVariantHash(params);317        self._flush(True);318        if not self._async:319            ret = self._read_return("enablePhotonAccumulation");320    def enablePreviewMode(self, enable):321        """322        | Enable (true) or disable (false) preview mode.323        | This mode enables faster OpenGL rendering at the cost of reduced quality.324        """325        self._check_connection();326        params = { "" : "enablePreviewMode"};327        params["enable"] = bool(enable);328        self._stream.writeQVariantHash(params);329        self._flush(True);330        if not self._async:331            ret = self._read_return("enablePreviewMode");332    def enableRaySharing(self, enable):333        """334        | Enable (true) or disable (false) reuse of rays for neighbors pixels (Raytracing only).335        | This optimization assumes pixels are acquired simultaneously.336        | It only works with SuMoL PSF!!337        """338        self._check_connection();339        params = { "" : "enableRaySharing"};340        params["enable"] = bool(enable);341        self._stream.writeQVariantHash(params);342        self._flush(True);343        if not self._async:344            ret = self._read_return("enableRaySharing");345    def enableRaytracing(self, enable):346        """347        | Enable (true) or disable (false) raytracing.348        """349        self._check_connection();350        params = { "" : "enableRaytracing"};351        params["enable"] = bool(enable);352        self._stream.writeQVariantHash(params);353        self._flush(True);354        if not self._async:355            ret = self._read_return("enableRaytracing");356    def enableRegularPSFSampling(self, enable):357        """358        | Enable (true) or disable (false) regular PSF sampling. It implies regular pixel sampling.359        """360        self._check_connection();361        params = { "" : "enableRegularPSFSampling"};362        params["enable"] = bool(enable);363        self._stream.writeQVariantHash(params);364        self._flush(True);365        if not self._async:366            ret = self._read_return("enableRegularPSFSampling");367    def enableRegularPixelSampling(self, enable):368        """369        | Enable (true) or disable (false) regular pixel sampling. It doesn't affect PSF sampling.370        """371        self._check_connection();372        params = { "" : "enableRegularPixelSampling"};373        params["enable"] = bool(enable);374        self._stream.writeQVariantHash(params);375        self._flush(True);376        if not self._async:377            ret = self._read_return("enableRegularPixelSampling");378    def enableScanningDeviceMode(self, enable):379        """380        | Enable (true) or disable (false) scanning device mode (Raytracing only).381        | Scanning device mode disables optimizations which assume a typical image projection.382        | This is useful for scanning LiDARs. It has the following characteristics:383        | - simulate a single detector cell (projection model applied to a 1x1 pixel matrix)384        | - does not support rendering stars385        | - PSF tail optimization (blooming) is disabled386        | - RaySharing is disabled387        """388        self._check_connection();389        params = { "" : "enableScanningDeviceMode"};390        params["enable"] = bool(enable);391        self._stream.writeQVariantHash(params);392        self._flush(True);393        if not self._async:394            ret = self._read_return("enableScanningDeviceMode");395    def enableSkipPixelSampling(self, enable):396        """397        | Enable (true) or disable (false) skipping the pixel surface sampling.398        | Enable only when PSF model is already integrated over the pixel surface otherwise image will be smoother than expected!399        | Default: disabled400        """401        self._check_connection();402        params = { "" : "enableSkipPixelSampling"};403        params["enable"] = bool(enable);404        self._stream.writeQVariantHash(params);405        self._flush(True);406        if not self._async:407            ret = self._read_return("enableSkipPixelSampling");408    def enableSpecularOptimization(self, enable):409        """410        | Enable a dedicated optimization for sampling specular reflections of the Sun (pathtracing only).411        """412        self._check_connection();413        params = { "" : "enableSpecularOptimization"};414        params["enable"] = bool(enable);415        self._stream.writeQVariantHash(params);416        self._flush(True);417        if not self._async:418            ret = self._read_return("enableSpecularOptimization");419    def enableTimeMapping(self, b_enable):420        """421        | enable or disable time mapping422        | If true, time map will be allocated on image generation. Otherwise it is destroyed if one was allocated before.423        | Time mapping only works in raytracing424        """425        self._check_connection();426        params = { "" : "enableTimeMapping"};427        params["b_enable"] = bool(b_enable);428        self._stream.writeQVariantHash(params);429        self._flush(True);430        if not self._async:431            ret = self._read_return("enableTimeMapping");432    def exists(self, object_name):433        """434        | Returns true if an object with the given name already exists.435        | This function checks aliases and builtin objects!436        """437        self._check_connection();438        params = { "" : "exists"};439        params["object_name"] = str(object_name);440        self._stream.writeQVariantHash(params);441        self._flush(True);442        ret = self._read_return("exists");443        return ret["exists"]444    def generateMicroTasks(self):445        """446        | Generate the list of Âµtasks required to render an image.447        | This is what makes possible to distribute the rendering process of a single image across several machines.448        | 449        | The format of the returned matrix is as follow (everything is encoded as double, types are given as hints):450        | cluster_id(int64), x(int32), y(int32), samples(int32), object_id(int32), start(s), end(s), weight([0-1]), flags(int)451        | 452        | NB: works in raytracing only!453        | WARNING: since cluster_id is stored as double, expect issues with images with width or height above 32.000.000 pixels454        """455        self._check_connection();456        params = { "" : "generateMicroTasks"};457        self._stream.writeQVariantHash(params);458        self._flush(True);459        ret = self._read_return("generateMicroTasks");460        return ret["utasks"]461    def getCameraFOVDeg(self):462        """463        | Return camera field of view in degrees.464        """465        self._check_connection();466        params = { "" : "getCameraFOVDeg"};467        self._stream.writeQVariantHash(params);468        self._flush(True);469        ret = self._read_return("getCameraFOVDeg");470        return ret["fov"]471    def getCameraFOVRad(self):472        """473        | Return camera field of view in radians.474        """475        self._check_connection();476        params = { "" : "getCameraFOVRad"};477        self._stream.writeQVariantHash(params);478        self._flush(True);479        ret = self._read_return("getCameraFOVRad");480        return ret["fov"]481    def getConventions(self):482        """483        | Get the active conventions for quaternions and camera frame definition.484        """485        self._check_connection();486        params = { "" : "getConventions"};487        self._stream.writeQVariantHash(params);488        self._flush(True);489        ret = self._read_return("getConventions");490        return ret["conventions"]491    def getCubeMapSize(self):492        """493        | Return the size of cube maps when creating new meshes.494        """495        self._check_connection();496        params = { "" : "getCubeMapSize"};497        self._stream.writeQVariantHash(params);498        self._flush(True);499        ret = self._read_return("getCubeMapSize");500        return ret["cube_map_size"]501    def getDoublePrecisionMode(self, *args, **kwargs):502        """503        | This function is deprecated and has been removed!504        | It has been replaced with a stub function to avoid legacy script failures.505        """506        self._check_connection();507        params = { "" : "getDoublePrecisionMode"};508        self._stream.writeQVariantHash(params);509        self._flush(True);510        self._read_return("getDoublePrecisionMode");511        return None;512    def getGlobalVariables(self):513        """514        | Return the values of active global SuMoL variables.515        | 516        """517        self._check_connection();518        params = { "" : "getGlobalVariables"};519        self._stream.writeQVariantHash(params);520        self._flush(True);521        ret = self._read_return("getGlobalVariables");522        return ret["names_and_values"]523    def getImageSize(self):524        """525        | Return the size of the image.526        """527        self._check_connection();528        params = { "" : "getImageSize"};529        self._stream.writeQVariantHash(params);530        self._flush(True);531        ret = self._read_return("getImageSize");532        return ret["size"]533    def getIntegrationTime(self):534        """535        | Return integration time in seconds.536        """537        self._check_connection();538        params = { "" : "getIntegrationTime"};539        self._stream.writeQVariantHash(params);540        self._flush(True);541        ret = self._read_return("getIntegrationTime");542        return ret["integration_time"]543    def getIrradianceMode(self):544        """545        | Return true if irradiance mode is enabled, false otherwise.546        """547        self._check_connection();548        params = { "" : "getIrradianceMode"};549        self._stream.writeQVariantHash(params);550        self._flush(True);551        ret = self._read_return("getIrradianceMode");552        return ret["enable"]553    def getLOSmapping(self):554        """555        | return true is LOS mapping is enabled, false otherwise.556        """557        self._check_connection();558        params = { "" : "getLOSmapping"};559        self._stream.writeQVariantHash(params);560        self._flush(True);561        ret = self._read_return("getLOSmapping");562        return ret["b_enable"]563    def getMaxSamplesPerPixel(self):564        """565        | Return the maximum number of samples allowed per pixel.566        """567        self._check_connection();568        params = { "" : "getMaxSamplesPerPixel"};569        self._stream.writeQVariantHash(params);570        self._flush(True);571        ret = self._read_return("getMaxSamplesPerPixel");572        return ret["max_samples"]573    def getMaxSecondaryRays(self):574        """575        | Return the number of secondary rays used for pathtracing.576        """577        self._check_connection();578        params = { "" : "getMaxSecondaryRays"};579        self._stream.writeQVariantHash(params);580        self._flush(True);581        ret = self._read_return("getMaxSecondaryRays");582        return ret["max_secondary_rays"]583    def getMaxShadowRays(self):584        """585        | Get the maximum number of rays used for direct shadows.586        | Default is 4.587        """588        self._check_connection();589        params = { "" : "getMaxShadowRays"};590        self._stream.writeQVariantHash(params);591        self._flush(True);592        ret = self._read_return("getMaxShadowRays");593        return ret["max_shadow_rays"]594    def getMetadata(self):595        """596        | Returns the metadata table597        """598        self._check_connection();599        params = { "" : "getMetadata"};600        self._stream.writeQVariantHash(params);601        self._flush(True);602        ret = self._read_return("getMetadata");603        return ret["metadata"]604    def getNbSamplesPerPixel(self):605        """606        | Return the number of samples per pixel.607        """608        self._check_connection();609        params = { "" : "getNbSamplesPerPixel"};610        self._stream.writeQVariantHash(params);611        self._flush(True);612        ret = self._read_return("getNbSamplesPerPixel");613        return ret["nb_samples"]614    def getObjectAttitude(self, object_name):615        """616        | Return the attitude of object 'object_name'.617        | Use 'camera' as object name to get the attitude of the camera.618        """619        self._check_connection();620        params = { "" : "getObjectAttitude"};621        params["object_name"] = str(object_name);622        self._stream.writeQVariantHash(params);623        self._flush(True);624        ret = self._read_return("getObjectAttitude");625        return ret["attitude"]626    def getObjectDynamicCubeMap(self, object_name):627        """628        | Return true if object 'object_name' has dynamic cube maps, false otherwise.629        | A dynamic cube map is updated at each frame whereas a static one is kept as is.630        | This is an OpenGL only option.631        """632        self._check_connection();633        params = { "" : "getObjectDynamicCubeMap"};634        params["object_name"] = str(object_name);635        self._stream.writeQVariantHash(params);636        self._flush(True);637        ret = self._read_return("getObjectDynamicCubeMap");638        return ret["enable"]639    def getObjectDynamicShadowMap(self, object_name):640        """641        | Return true if object 'object_name' has dynamic shadow maps, false otherwise.642        | A dynamic shadow map is updated at each frame whereas a static one is kept as is.643        | This is an OpenGL only option.644        """645        self._check_connection();646        params = { "" : "getObjectDynamicShadowMap"};647        params["object_name"] = str(object_name);648        self._stream.writeQVariantHash(params);649        self._flush(True);650        ret = self._read_return("getObjectDynamicShadowMap");651        return ret["enable"]652    def getObjectElementProperty(self, name, element_name, property):653        """654        | Return the value of property 'property' for element 'element_name' in object 'name'.655        """656        self._check_connection();657        params = { "" : "getObjectElementProperty"};658        params["name"] = str(name);659        params["element_name"] = str(element_name);660        params["property"] = str(property);661        self._stream.writeQVariantHash(params);662        self._flush(True);663        ret = self._read_return("getObjectElementProperty");664        return ret["value"]665    def getObjectMotion(self, object_name):666        """667        | Return motion parameters for object 'object_name'.668        """669        self._check_connection();670        params = { "" : "getObjectMotion"};671        params["object_name"] = str(object_name);672        self._stream.writeQVariantHash(params);673        self._flush(True);674        ret = self._read_return("getObjectMotion");675        return ret["motion"]676    def getObjectPosition(self, object_name):677        """678        | Return the position of object 'object_name'.679        | Use 'camera' as object name to get the position of the camera.680        """681        self._check_connection();682        params = { "" : "getObjectPosition"};683        params["object_name"] = str(object_name);684        self._stream.writeQVariantHash(params);685        self._flush(True);686        ret = self._read_return("getObjectPosition");687        return ret["pos"]688    def getObjectProperty(self, name, property):689        """690        | Return the value of property 'property' for object 'name'.691        """692        self._check_connection();693        params = { "" : "getObjectProperty"};694        params["name"] = str(name);695        params["property"] = str(property);696        self._stream.writeQVariantHash(params);697        self._flush(True);698        ret = self._read_return("getObjectProperty");699        return ret["value"]700    def getObjectSamples(self, object_name):701        """702        | Return the required number of rays for object 'object_name'.703        """704        self._check_connection();705        params = { "" : "getObjectSamples"};706        params["object_name"] = str(object_name);707        self._stream.writeQVariantHash(params);708        self._flush(True);709        ret = self._read_return("getObjectSamples");710        return ret["nb_samples"]711    def getPhotonMapSamplingStep(self):712        """713        | Return the sampling step for photon maps.714        """715        self._check_connection();716        params = { "" : "getPhotonMapSamplingStep"};717        self._stream.writeQVariantHash(params);718        self._flush(True);719        ret = self._read_return("getPhotonMapSamplingStep");720        return ret["step"]721    def getPreviewMode(self):722        """723        | Return true if preview mode is enabled, false otherwise.724        """725        self._check_connection();726        params = { "" : "getPreviewMode"};727        self._stream.writeQVariantHash(params);728        self._flush(True);729        ret = self._read_return("getPreviewMode");730        return ret["enable"]731    def getRessourcePath(self):732        """733        | Return current path to ressource files.734        """735        self._check_connection();736        params = { "" : "getRessourcePath"};737        self._stream.writeQVariantHash(params);738        self._flush(True);739        ret = self._read_return("getRessourcePath");740        return ret["ressource_path"]741    def getScanningDeviceMode(self):742        """743        | Return the status of scanning device mode.744        """745        self._check_connection();746        params = { "" : "getScanningDeviceMode"};747        self._stream.writeQVariantHash(params);748        self._flush(True);749        ret = self._read_return("getScanningDeviceMode");750        return ret["enable"]751    def getSelfVisibilitySamplingStep(self):752        """753        | Return the sampling step for self visibility maps.754        """755        self._check_connection();756        params = { "" : "getSelfVisibilitySamplingStep"};757        self._stream.writeQVariantHash(params);758        self._flush(True);759        ret = self._read_return("getSelfVisibilitySamplingStep");760        return ret["step"]761    def getShadowMapSize(self):762        """763        | Return the size of shadow maps when creating new meshes.764        """765        self._check_connection();766        params = { "" : "getShadowMapSize"};767        self._stream.writeQVariantHash(params);768        self._flush(True);769        ret = self._read_return("getShadowMapSize");770        return ret["shadow_map_size"]771    def getState(self):772        """773        | Return the state of the scene manager as a string.774        | This state contains position,attitude,motion of all objects in the scene as well as renderer settings.775        """776        self._check_connection();777        params = { "" : "getState"};778        self._stream.writeQVariantHash(params);779        self._flush(True);780        ret = self._read_return("getState");781        return ret["state"]782    def getSunPower(self):783        """784        | Return the power of the sun.785        """786        self._check_connection();787        params = { "" : "getSunPower"};788        self._stream.writeQVariantHash(params);789        self._flush(True);790        ret = self._read_return("getSunPower");791        return ret["sun_power"]792    def getTimeMapping(self):793        """794        | return true is time mapping is enabled, false otherwise.795        """796        self._check_connection();797        params = { "" : "getTimeMapping"};798        self._stream.writeQVariantHash(params);799        self._flush(True);800        ret = self._read_return("getTimeMapping");801        return ret["b_enable"]802    def help(self, function_name):803        """804        | Print the available documentation for function 'function_name'.805        """806        self._check_connection();807        params = { "" : "help"};808        params["function_name"] = str(function_name);809        self._stream.writeQVariantHash(params);810        self._flush(True);811        ret = self._read_return("help");812        print(ret['help']);813        return ret["help"]814    def intersectScene(self, rays):815        """816        | Compute the intersection of a set of rays with the scene817        | Each ray is stored as a (position,direction) pair in a std::vector/list818        | Returns the distance to the hit along each ray.819        """820        self._check_connection();821        params = { "" : "intersectScene"};822        params["rays"] = rays;823        self._stream.writeQVariantHash(params);824        self._flush(True);825        ret = self._read_return("intersectScene");826        return ret["distance_to_hit"]827    def loadAndProjectMultipleMeshes(self, object_name, mesh_names, positions, attitudes, projection_center, offset_ratio):828        """829        | Like loadMultipleMeshes it loads a list of meshes with the given positions and attitudes into a single object.830        | A quaternion on the unit sphere is a simple rotation, otherwise its norm is interpreted as a scaling factor.831        | The difference with loadMultipleMeshes is the projection of the given position onto the scene towards a projection center.832        | This point is defined in homogeneous coordinates and can be set at inifinity by setting its last coordinate to 0.833        | The last parameter is the offset, relative to the radius of each instance's bounding sphere, from the surface to the center of each object.834        | An offset_ratio of 0 means the center is on the surface, 1 means a sphere would be at the limit of penetrating the surface.835        """836        self._check_connection();837        params = { "" : "loadAndProjectMultipleMeshes"};838        params["object_name"] = str(object_name);839        params["mesh_names"] = mesh_names;840        params["positions"] = positions;841        params["attitudes"] = attitudes;842        params["projection_center"] = self._vec(projection_center);843        params["offset_ratio"] = float(offset_ratio);844        self._stream.writeQVariantHash(params);845        self._flush(True);846        if not self._async:847            ret = self._read_return("loadAndProjectMultipleMeshes");848    def loadMotionModel(self, filename, parameters):849        """850        | Load a motion model written in SuMoL from the file 'filename' with the parameters in 'parameters'.851        | A motion model defines the camera motion during image acquisition, it can also define microvibrations.852        """853        self._check_connection();854        params = { "" : "loadMotionModel"};855        params["filename"] = str(filename);856        params["parameters"] = parameters;857        self._stream.writeQVariantHash(params);858        self._flush(True);859        if not self._async:860            ret = self._read_return("loadMotionModel");861    def loadMultipleMeshes(self, object_name, mesh_names, positions, attitudes):862        """863        | Load a list of meshes with the given positions and attitudes into a single object.864        | A quaternion on the unit sphere is a simple rotation, otherwise its norm is interpreted as a scaling factor.865        """866        self._check_connection();867        params = { "" : "loadMultipleMeshes"};868        params["object_name"] = str(object_name);869        params["mesh_names"] = mesh_names;870        params["positions"] = positions;871        params["attitudes"] = attitudes;872        self._stream.writeQVariantHash(params);873        self._flush(True);874        if not self._async:875            ret = self._read_return("loadMultipleMeshes");876    def loadPSFModel(self, filename, parameters):877        """878        | Load a PSF model written in SuMoL from the file 'filename' with the parameters in 'parameters'.879        | A PSF model defines the PSF integral.880        """881        self._check_connection();882        params = { "" : "loadPSFModel"};883        params["filename"] = str(filename);884        params["parameters"] = parameters;885        self._stream.writeQVariantHash(params);886        self._flush(True);887        if not self._async:888            ret = self._read_return("loadPSFModel");889    def loadProjectionModel(self, filename, parameters):890        """891        | Load a projection model written in SuMoL from the file 'filename' with the parameters in 'parameters'.892        | A projection model defines both the projection to image plane and the optical distortion.893        """894        self._check_connection();895        params = { "" : "loadProjectionModel"};896        params["filename"] = str(filename);897        params["parameters"] = parameters;898        self._stream.writeQVariantHash(params);899        self._flush(True);900        if not self._async:901            ret = self._read_return("loadProjectionModel");902    def loadSpectrumModel(self, filename, parameters):903        """904        | Load a Spectrum model written in SuMoL from the file 'filename' with the parameters in 'parameters'.905        | A Spectrum model defines how a 4D color spectrum is converted into a continuous one and how the spectrum is sampled.906        | This is required to simulate achromatism (with a PSF model with a dependency to lambda).907        """908        self._check_connection();909        params = { "" : "loadSpectrumModel"};910        params["filename"] = str(filename);911        params["parameters"] = parameters;912        self._stream.writeQVariantHash(params);913        self._flush(True);914        if not self._async:915            ret = self._read_return("loadSpectrumModel");916    def loadTextureObject(self, name, filename, parameters):917        """918        | Load a texture. It can be any supported type of image format.919        | It can also be a procedural texture model written in SuMoL from the file 'filename' with the parameters in 'parameters' and give it the the name 'name'.920        | A procedural texture model describes a 2D or 3D texture (4D color spectrum) using lookup functions.921        """922        self._check_connection();923        params = { "" : "loadTextureObject"};924        params["name"] = str(name);925        params["filename"] = str(filename);926        params["parameters"] = parameters;927        self._stream.writeQVariantHash(params);928        self._flush(True);929        if not self._async:930            ret = self._read_return("loadTextureObject");931    def loadTimeSamplingModel(self, filename, parameters):932        """933        | Load a sampling model (raytracing) which defines when and for how long pixels gather light.934        | The model is loaded from the SuMoL file 'filename' with the parameters 'parameters'.935        """936        self._check_connection();937        params = { "" : "loadTimeSamplingModel"};938        params["filename"] = str(filename);939        params["parameters"] = parameters;940        self._stream.writeQVariantHash(params);941        self._flush(True);942        if not self._async:943            ret = self._read_return("loadTimeSamplingModel");944    def ls(self):945        """946        | List the content of the current resource path947        | This is similar to the 'ls -lh' command on Linux.948        """949        self._check_connection();950        params = { "" : "ls"};951        self._stream.writeQVariantHash(params);952        self._flush(True);953        ret = self._read_return("ls");954        print(ret['listing']);955        return ret["listing"]956    def printAPI(self):957        """958        | List all the functions of the client API.959        """960        self._check_connection();961        params = { "" : "printAPI"};962        self._stream.writeQVariantHash(params);963        self._flush(True);964        ret = self._read_return("printAPI");965        print(ret['api']);966        return ret["api"]967    def printObjectStructure(self, object_name):968        """969        | Print the structure of object 'object_name'.970        """971        self._check_connection();972        params = { "" : "printObjectStructure"};973        params["object_name"] = str(object_name);974        self._stream.writeQVariantHash(params);975        self._flush(True);976        ret = self._read_return("printObjectStructure");977        print(ret['object_structure']);978        return ret["object_structure"]979    def printState(self, state):980        """981        | Generates a human readable string representation of a saved state.982        """983        self._check_connection();984        params = { "" : "printState"};985        params["state"] = str(state);986        self._stream.writeQVariantHash(params);987        self._flush(True);988        ret = self._read_return("printState");989        print(ret['readable_state']);990        return ret["readable_state"]991    def pwd(self):992        """993        | Return the current resource path.994        | This is similar to the 'pwd' command on Linux.995        """996        self._check_connection();997        params = { "" : "pwd"};998        self._stream.writeQVariantHash(params);999        self._flush(True);1000        ret = self._read_return("pwd");1001        print(ret['path']);1002        return ret["path"]1003    def render(self):1004        """1005        | Render an image with current parameters.1006        """1007        self._check_connection();1008        params = { "" : "render"};1009        self._stream.writeQVariantHash(params);1010        self._flush(True);1011        if not self._async:1012            ret = self._read_return("render");1013    def renderMicroTasks(self, utasks):1014        """1015        | Render an image using a pregenerated list of Âµtasks1016        | This is what makes possible to distribute the rendering process of a single image across several machines.1017        | Using this function one can generate only a fraction of an image which can be split to be generated on several machines in parallel.1018        | 1019        | NB: works in raytracing only1020        """1021        self._check_connection();1022        params = { "" : "renderMicroTasks"};1023        params["utasks"] = utasks;1024        self._stream.writeQVariantHash(params);1025        self._flush(True);1026        if not self._async:1027            ret = self._read_return("renderMicroTasks");1028    def reset(self):1029        """1030        | Reset the engine.1031        | All ressources are freed, all scene objects/elements are deleted.1032        """1033        self._check_connection();1034        params = { "" : "reset"};1035        self._stream.writeQVariantHash(params);1036        self._flush(True);1037        if not self._async:1038            ret = self._read_return("reset");1039    def runPerPixelProcess(self, output_name, process_name):1040        """1041        | Run a function on each pixel of a texture.1042        | If 'output_name' is empty, it targets the framebuffer (rendered image buffer).1043        | You must create the PerPixelProcess object first with createPerPixelProcess.1044        """1045        self._check_connection();1046        params = { "" : "runPerPixelProcess"};1047        params["output_name"] = str(output_name);1048        params["process_name"] = str(process_name);1049        self._stream.writeQVariantHash(params);1050        self._flush(True);1051        if not self._async:1052            ret = self._read_return("runPerPixelProcess");1053    def saveDepthMap(self, filename):1054        """1055        | Save the depth map in file 'filename'. Only TIF format is supported.1056        """1057        self._check_connection();1058        params = { "" : "saveDepthMap"};1059        params["filename"] = str(filename);1060        self._stream.writeQVariantHash(params);1061        self._flush(True);1062        if not self._async:1063            ret = self._read_return("saveDepthMap");1064    def saveImage(self, filename):1065        """1066        | Save the image in file 'filename'. File format is guessed from extension.1067        | [0-1] range is mapped to 8bits when required.1068        """1069        self._check_connection();1070        params = { "" : "saveImage"};1071        params["filename"] = str(filename);1072        self._stream.writeQVariantHash(params);1073        self._flush(True);1074        if not self._async:1075            ret = self._read_return("saveImage");1076    def saveImageGray32F(self, filename):1077        """1078        | Save the image in file 'filename'. File format is guessed from extension.1079        | The first 3 channels are averaged and the result is stored in float format.1080        """1081        self._check_connection();1082        params = { "" : "saveImageGray32F"};1083        params["filename"] = str(filename);1084        self._stream.writeQVariantHash(params);1085        self._flush(True);1086        if not self._async:1087            ret = self._read_return("saveImageGray32F");1088    def saveImageGray8(self, filename):1089        """1090        | Save the image in file 'filename'. File format is guessed from extension.1091        | [0-1] range is mapped to 8bits and the first 3 channels are averaged.1092        """1093        self._check_connection();1094        params = { "" : "saveImageGray8"};1095        params["filename"] = str(filename);1096        self._stream.writeQVariantHash(params);1097        self._flush(True);1098        if not self._async:1099            ret = self._read_return("saveImageGray8");1100    def saveImageRGB8(self, filename):1101        """1102        | Save the image in file 'filename'. File format is guessed from extension.1103        | [0-1] range is mapped to 8bits and only the first 3 channels are considered.1104        """1105        self._check_connection();1106        params = { "" : "saveImageRGB8"};1107        params["filename"] = str(filename);1108        self._stream.writeQVariantHash(params);1109        self._flush(True);1110        if not self._async:1111            ret = self._read_return("saveImageRGB8");1112    def saveImageSpectrumProjection(self, filename, spectrum):1113        """1114        | Save the image in file 'filename'. File format is guessed from extension.1115        | The 4 channels are weighted according to the 'spectrum' parameter and the result is stored in float format.1116        """1117        self._check_connection();1118        params = { "" : "saveImageSpectrumProjection"};1119        params["filename"] = str(filename);1120        params["spectrum"] = self._vec(spectrum);1121        self._stream.writeQVariantHash(params);1122        self._flush(True);1123        if not self._async:1124            ret = self._read_return("saveImageSpectrumProjection");1125    def saveImageSpectrumProjectionQuantized(self, filename, spectrum, nbits):1126        """1127        | Save the image in file 'filename'. File format is guessed from extension.1128        | The 4 channels are weighted according to the 'spectrum' parameter and the result is stored in integer 8/16bits format after quantization.1129        | This last step is done using 'nbits' to define the valid range. If nbits <= 8, the result is stored in an 8bits image, otherwise it is stored in a 16bits image.1130        """1131        self._check_connection();1132        params = { "" : "saveImageSpectrumProjectionQuantized"};1133        params["filename"] = str(filename);1134        params["spectrum"] = self._vec(spectrum);1135        params["nbits"] = int(nbits);1136        self._stream.writeQVariantHash(params);1137        self._flush(True);1138        if not self._async:1139            ret = self._read_return("saveImageSpectrumProjectionQuantized");1140    def saveObject(self, object_name, filename):1141        """1142        | Save object 'object_name' to file 'filename'.1143        """1144        self._check_connection();1145        params = { "" : "saveObject"};1146        params["object_name"] = str(object_name);1147        params["filename"] = str(filename);1148        self._stream.writeQVariantHash(params);1149        self._flush(True);1150        if not self._async:1151            ret = self._read_return("saveObject");1152    def setAlias(self, object_name, alias):1153        """1154        | Create an alias for an existing object.1155        """1156        self._check_connection();1157        params = { "" : "setAlias"};1158        params["object_name"] = str(object_name);1159        params["alias"] = str(alias);1160        self._stream.writeQVariantHash(params);1161        self._flush(True);1162        if not self._async:1163            ret = self._read_return("setAlias");1164    def setBackground(self, background):1165        """1166        | Set the background to render: either a spherical texture or a star map.1167        """1168        self._check_connection();1169        params = { "" : "setBackground"};1170        params["background"] = str(background);1171        self._stream.writeQVariantHash(params);1172        self._flush(True);1173        if not self._async:1174            ret = self._read_return("setBackground");1175    def setCameraFOVDeg(self, fov_x, fov_y):1176        """1177        | Set camera field of view in degrees.1178        """1179        self._check_connection();1180        params = { "" : "setCameraFOVDeg"};1181        params["fov_x"] = float(fov_x);1182        params["fov_y"] = float(fov_y);1183        self._stream.writeQVariantHash(params);1184        self._flush(True);1185        if not self._async:1186            ret = self._read_return("setCameraFOVDeg");1187    def setCameraFOVRad(self, fov_x, fov_y):1188        """1189        | Set camera field of view in radians.1190        """1191        self._check_connection();1192        params = { "" : "setCameraFOVRad"};1193        params["fov_x"] = float(fov_x);1194        params["fov_y"] = float(fov_y);1195        self._stream.writeQVariantHash(params);1196        self._flush(True);1197        if not self._async:1198            ret = self._read_return("setCameraFOVRad");1199    def setConventions(self, quaternion_convention, camera_convention):1200        """1201        | Set the conventions for quaternions and camera frame definition.1202        """1203        self._check_connection();1204        params = { "" : "setConventions"};1205        params["quaternion_convention"] = int(quaternion_convention);1206        params["camera_convention"] = int(camera_convention);1207        self._stream.writeQVariantHash(params);1208        self._flush(True);1209        if not self._async:1210            ret = self._read_return("setConventions");1211    def setCubeMapSize(self, cube_map_size):1212        """1213        | Set the size of cube maps when creating new meshes.1214        """1215        self._check_connection();1216        params = { "" : "setCubeMapSize"};1217        params["cube_map_size"] = cube_map_size;1218        self._stream.writeQVariantHash(params);1219        self._flush(True);1220        if not self._async:1221            ret = self._read_return("setCubeMapSize");1222    def setCubeMapZNear(self, znear):1223        """1224        | Set the distance (in meters) of the near plane when rendering cubemaps. Default is 10km.1225        """1226        self._check_connection();1227        params = { "" : "setCubeMapZNear"};1228        params["znear"] = float(znear);1229        self._stream.writeQVariantHash(params);1230        self._flush(True);1231        if not self._async:1232            ret = self._read_return("setCubeMapZNear");1233    def setFSAA(self, fsaa):1234        """1235        | Set the super sampling factor in OpenGL mode. 1 means disabled.1236        | The number of samples per pixel is equal to this parameter squared.1237        | Disabled by default.1238        """1239        self._check_connection();1240        params = { "" : "setFSAA"};1241        params["fsaa"] = int(fsaa);1242        self._stream.writeQVariantHash(params);1243        self._flush(True);1244        if not self._async:1245            ret = self._read_return("setFSAA");1246    def setFocus(self, focus_plane_Z, pupil_radius):1247        """1248        | Set parameters for defocus/depth of field simulation.1249        | If focus_plane_Z or pupil_radius is set to 0, defocus/depth of field is not simulated.1250        | 1251        | Default: disabled1252        """1253        self._check_connection();1254        params = { "" : "setFocus"};1255        params["focus_plane_Z"] = float(focus_plane_Z);1256        params["pupil_radius"] = float(pupil_radius);1257        self._stream.writeQVariantHash(params);1258        self._flush(True);1259        if not self._async:1260            ret = self._read_return("setFocus");1261    def setGlobalVariables(self, names_and_values):1262        """1263        | Set the values of a set of global SuMoL variables.1264        | NB: this only affects globals for already loaded SuMoL models. When loading a new model its globals will be kept at their default values!1265        """1266        self._check_connection();1267        params = { "" : "setGlobalVariables"};1268        params["names_and_values"] = names_and_values;1269        self._stream.writeQVariantHash(params);1270        self._flush(True);1271        if not self._async:1272            ret = self._read_return("setGlobalVariables");1273    def setImageSize(self, width, height):1274        """1275        | Set image size.1276        """1277        self._check_connection();1278        params = { "" : "setImageSize"};1279        params["width"] = width;1280        params["height"] = height;1281        self._stream.writeQVariantHash(params);1282        self._flush(True);1283        if not self._async:1284            ret = self._read_return("setImageSize");1285    def setIntegrationTime(self, integration_time):1286        """1287        | Set integration time in seconds.1288        | NB: if using a sensor model, please refer to its API instead of this function.1289        """1290        self._check_connection();1291        params = { "" : "setIntegrationTime"};1292        params["integration_time"] = float(integration_time);1293        self._stream.writeQVariantHash(params);1294        self._flush(True);1295        if not self._async:1296            ret = self._read_return("setIntegrationTime");1297    def setMaxSamplesPerPixel(self, max_samples):1298        """1299        | Set the maximum number of samples per pixel when dynamically increased to reduce noise on edges.1300        """1301        self._check_connection();1302        params = { "" : "setMaxSamplesPerPixel"};1303        params["max_samples"] = int(max_samples);1304        self._stream.writeQVariantHash(params);1305        self._flush(True);1306        if not self._async:1307            ret = self._read_return("setMaxSamplesPerPixel");1308    def setMaxSecondaryRays(self, max_secondary_rays):1309        """1310        | Set the maximum number of secondary rays (default is 4) when pathtracing is enabled.1311        """1312        self._check_connection();1313        params = { "" : "setMaxSecondaryRays"};1314        params["max_secondary_rays"] = int(max_secondary_rays);1315        self._stream.writeQVariantHash(params);1316        self._flush(True);1317        if not self._async:1318            ret = self._read_return("setMaxSecondaryRays");1319    def setMaxShadowRays(self, max_shadow_rays):1320        """1321        | Set the maximum number of rays used for direct shadows.1322        | Default is 4.1323        """1324        self._check_connection();1325        params = { "" : "setMaxShadowRays"};1326        params["max_shadow_rays"] = int(max_shadow_rays);1327        self._stream.writeQVariantHash(params);1328        self._flush(True);1329        if not self._async:1330            ret = self._read_return("setMaxShadowRays");1331    def setMetadata(self, name, value):1332        """1333        | Add, update or remove a metadata1334        | If value is empty, the metadata is removed1335        | Metadata are used when sending images over TCP. This is typically used to store timestamps and image IDs.1336        """1337        self._check_connection();1338        params = { "" : "setMetadata"};1339        params["name"] = str(name);1340        params["value"] = value;1341        self._stream.writeQVariantHash(params);1342        self._flush(True);1343        if not self._async:1344            ret = self._read_return("setMetadata");1345    def setNbSamplesPerPixel(self, nb_samples):1346        """1347        | Set the number of samples per pixel (raytracing).1348        """1349        self._check_connection();1350        params = { "" : "setNbSamplesPerPixel"};1351        params["nb_samples"] = int(nb_samples);1352        self._stream.writeQVariantHash(params);1353        self._flush(True);1354        if not self._async:1355            ret = self._read_return("setNbSamplesPerPixel");1356    def setNearPlane(self, z):1357        """1358        | Set the distance of the near plane (OpenGL only). Objects or parts of objects closer than this distance won't be rendered.1359        """1360        self._check_connection();1361        params = { "" : "setNearPlane"};1362        params["z"] = float(z);1363        self._stream.writeQVariantHash(params);1364        self._flush(True);1365        if not self._async:1366            ret = self._read_return("setNearPlane");1367    def setObjectAttitude(self, object_name, attitude):1368        """1369        | Set the attitude of object 'object_name'.1370        | Use 'camera' as object name to change the attitude of the camera.1371        """1372        self._check_connection();1373        params = { "" : "setObjectAttitude"};1374        params["object_name"] = str(object_name);1375        params["attitude"] = self._vec(attitude);1376        self._stream.writeQVariantHash(params);1377        self._flush(True);1378        if not self._async:1379            ret = self._read_return("setObjectAttitude");1380    def setObjectDynamicCubeMap(self, object_name, enable):1381        """1382        | Enable (true) or disable (false) dynamic cube maps for object 'object_name'.1383        | A dynamic cube map is updated at each frame whereas a static one is kept as is.1384        | This is an OpenGL only option.1385        """1386        self._check_connection();1387        params = { "" : "setObjectDynamicCubeMap"};1388        params["object_name"] = str(object_name);1389        params["enable"] = bool(enable);1390        self._stream.writeQVariantHash(params);1391        self._flush(True);1392        if not self._async:1393            ret = self._read_return("setObjectDynamicCubeMap");1394    def setObjectDynamicShadowMap(self, object_name, enable):1395        """1396        | Enable (true) or disable (false) dynamic shadow maps for object 'object_name'.1397        | A dynamic shadow map is updated at each frame whereas a static one is kept as is.1398        | This is an OpenGL only option.1399        """1400        self._check_connection();1401        params = { "" : "setObjectDynamicShadowMap"};1402        params["object_name"] = str(object_name);1403        params["enable"] = bool(enable);1404        self._stream.writeQVariantHash(params);1405        self._flush(True);1406        if not self._async:1407            ret = self._read_return("setObjectDynamicShadowMap");1408    def setObjectElementBRDF(self, object_name, element_name, brdf):1409        """1410        | Set the BRDF for an element of an object.1411        | If 'object_name' = 'element_name' the BRDF is applied to the whole object.1412        """1413        self._check_connection();1414        params = { "" : "setObjectElementBRDF"};1415        params["object_name"] = str(object_name);1416        params["element_name"] = str(element_name);1417        params["brdf"] = str(brdf);1418        self._stream.writeQVariantHash(params);1419        self._flush(True);1420        if not self._async:1421            ret = self._read_return("setObjectElementBRDF");1422    def setObjectElementProperty(self, name, element_name, property, value):1423        """1424        | Set property 'property' to 'value' for element 'element_name' in object 'name'.1425        | Available properties are:1426        | photon_map_sampling_step          Sampling step (distance between samples) for this element in the photon map.1427        |                                   If 0, no samples will be generated for this object.1428        |                                   If < 0.0, density is inherited from parent node.1429        """1430        self._check_connection();1431        params = { "" : "setObjectElementProperty"};1432        params["name"] = str(name);1433        params["element_name"] = str(element_name);1434        params["property"] = str(property);1435        params["value"] = float(value);1436        self._stream.writeQVariantHash(params);1437        self._flush(True);1438        if not self._async:1439            ret = self._read_return("setObjectElementProperty");1440    def setObjectElementTransform(self, object_name, element_name, matrix, relative):1441        """1442        | Set the local (relative = true) or global (relative = false) transformation1443        | of an element of an object. 'matrix' is a 4x4 matrix representing this transformation.1444        """1445        self._check_connection();1446        params = { "" : "setObjectElementTransform"};1447        params["object_name"] = str(object_name);1448        params["element_name"] = str(element_name);1449        params["matrix"] = self._mat44(matrix);1450        params["relative"] = bool(relative);1451        self._stream.writeQVariantHash(params);1452        self._flush(True);1453        if not self._async:1454            ret = self._read_return("setObjectElementTransform");1455    def setObjectMotion(self, object_name, motion):1456        """1457        | Set motion parameters (speed & rotation speed) for object 'object_name'.1458        """1459        self._check_connection();1460        params = { "" : "setObjectMotion"};1461        params["object_name"] = str(object_name);1462        params["motion"] = [ self._vec(motion[0]), self._vec(motion[1]) ];1463        self._stream.writeQVariantHash(params);1464        self._flush(True);1465        if not self._async:1466            ret = self._read_return("setObjectMotion");1467    def setObjectPosition(self, object_name, pos):1468        """1469        | Set the position of object 'object_name'.1470        | Use 'camera' as object name to change the position of the camera.1471        """1472        self._check_connection();1473        params = { "" : "setObjectPosition"};1474        params["object_name"] = str(object_name);1475        params["pos"] = self._vec(pos);1476        self._stream.writeQVariantHash(params);1477        self._flush(True);1478        if not self._async:1479            ret = self._read_return("setObjectPosition");1480    def setObjectProperty(self, name, property, value):1481        """1482        | Set property 'property' to 'value' for object 'name'.1483        | Available properties are:1484        | photon_map (boolean)              If true object will have a photon map to accumulate energy received on its surface.1485        | normal_map_object_space (boolean) If true normal maps are read in object frame instead of tangent space.1486        | skip_path_tracing (boolean)       If true the object won't be sampled as a secondary light source when pathtracing is enabled.1487        """1488        self._check_connection();1489        params = { "" : "setObjectProperty"};1490        params["name"] = str(name);1491        params["property"] = str(property);1492        params["value"] = float(value);1493        self._stream.writeQVariantHash(params);1494        self._flush(True);1495        if not self._async:1496            ret = self._read_return("setObjectProperty");1497    def setObjectSamples(self, object_name, nb_samples):1498        """1499        | Set a quota of samples to cast over an object.1500        | Surrender will cast at least that many primary rays toward this object.1501        """1502        self._check_connection();1503        params = { "" : "setObjectSamples"};1504        params["object_name"] = str(object_name);1505        params["nb_samples"] = float(nb_samples);1506        self._stream.writeQVariantHash(params);1507        self._flush(True);1508        if not self._async:1509            ret = self._read_return("setObjectSamples");1510    def setPSFSigma(self, sigma):1511        """1512        | Set the sigma parameter of a gaussian PSF in OpenGL mode. 0.0 means disabled.1513        | Disabled by default.1514        """1515        self._check_connection();1516        params = { "" : "setPSFSigma"};1517        params["sigma"] = float(sigma);1518        self._stream.writeQVariantHash(params);1519        self._flush(True);1520        if not self._async:1521            ret = self._read_return("setPSFSigma");1522    def setPhotonMapSamplingStep(self, step):1523        """1524        | Set the sampling step for generating photon maps (for meshes) in pathtracing.1525        | Default value is 1e-1. Reducing this value produces better results but requires more memory and more processing time (more rays).1526        """1527        self._check_connection();1528        params = { "" : "setPhotonMapSamplingStep"};1529        params["step"] = float(step);1530        self._stream.writeQVariantHash(params);1531        self._flush(True);1532        if not self._async:1533            ret = self._read_return("setPhotonMapSamplingStep");1534    def setRessourcePath(self, ressource_path):1535        """1536        | Set the reference path (server side) to access ressources (models, textures, ...).1537        """1538        self._check_connection();1539        params = { "" : "setRessourcePath"};1540        params["ressource_path"] = str(ressource_path);1541        self._stream.writeQVariantHash(params);1542        self._flush(True);1543        if not self._async:1544            ret = self._read_return("setRessourcePath");1545    def setSelfVisibilitySamplingStep(self, step):1546        """1547        | Set the sampling step for generating self visibility maps (for meshes) in pathtracing.1548        | Default value is 1e-1. Reducing this value produces better results but requires more memory and more preprocessing time.1549        """1550        self._check_connection();1551        params = { "" : "setSelfVisibilitySamplingStep"};1552        params["step"] = float(step);1553        self._stream.writeQVariantHash(params);1554        self._flush(True);1555        if not self._async:1556            ret = self._read_return("setSelfVisibilitySamplingStep");1557    def setShadowMapSize(self, shadow_map_size):1558        """1559        | Set the size of shadow maps when creating new meshes.1560        """1561        self._check_connection();1562        params = { "" : "setShadowMapSize"};1563        params["shadow_map_size"] = shadow_map_size;1564        self._stream.writeQVariantHash(params);1565        self._flush(True);1566        if not self._async:1567            ret = self._read_return("setShadowMapSize");1568    def setStarThreshold(self, threshold):1569        """1570        | Set the lowest value (in W/m^2) for a star to be rendered.1571        | If any spectrum component is above this threshold the star will be rendered otherwise it will be ignored.1572        | Default is 0.1573        | 1574        | NB: applies only to raytracing1575        | 1576        """1577        self._check_connection();1578        params = { "" : "setStarThreshold"};1579        params["threshold"] = float(threshold);1580        self._stream.writeQVariantHash(params);1581        self._flush(True);1582        if not self._async:1583            ret = self._read_return("setStarThreshold");1584    def setState(self, state):1585        """1586        | Restores a previously saved state of the scene manager.1587        | This will restore position,attitude,motion of all objects in the scene as well as renderer settings.1588        | Objects are not created, they must exist in the scene before restoring the scene state.1589        """1590        self._check_connection();1591        params = { "" : "setState"};1592        params["state"] = str(state);1593        self._stream.writeQVariantHash(params);1594        self._flush(True);1595        if not self._async:1596            ret = self._read_return("setState");1597    def setSunPower(self, sun_color):1598        """1599        | Set the power emitted by the Sun for each wave length simulated.1600        | This is expressed in W/sr.1601        """1602        self._check_connection();1603        params = { "" : "setSunPower"};1604        params["sun_color"] = self._vec(sun_color);1605        self._stream.writeQVariantHash(params);1606        self._flush(True);1607        if not self._async:1608            ret = self._read_return("setSunPower");1609    def setSunPowerAtDistance(self, sun_color, distance):1610        """1611        | Set the received from the Sun for each wave length simulated at a given distance.1612        | This is expressed in W/mÂ² for the power and in m for the distance.1613        """1614        self._check_connection();1615        params = { "" : "setSunPowerAtDistance"};1616        params["sun_color"] = self._vec(sun_color);1617        params["distance"] = float(distance);1618        self._stream.writeQVariantHash(params);1619        self._flush(True);1620        if not self._async:1621            ret = self._read_return("setSunPowerAtDistance");1622    def updateDisplay(self):1623        """1624        | Update viewer window on the server side.1625        | This is useful after framebuffer has been modified with a PerPixelProcess1626        """1627        self._check_connection();1628        params = { "" : "updateDisplay"};1629        self._stream.writeQVariantHash(params);1630        self._flush(True);1631        if not self._async:1632            ret = self._read_return("updateDisplay");1633    def updateDynamicTexture(self, name):1634        """1635        | Trigger an update of the dynamic texture 'name'.1636        """1637        self._check_connection();1638        params = { "" : "updateDynamicTexture"};1639        params["name"] = str(name);1640        self._stream.writeQVariantHash(params);1641        self._flush(True);1642        if not self._async:1643            ret = self._read_return("updateDynamicTexture");1644    def version(self):1645        """1646        | Returns the server version number and GIT revision if available.1647        """1648        self._check_connection();1649        params = { "" : "version"};1650        self._stream.writeQVariantHash(params);1651        self._flush(True);1652        ret = self._read_return("version");...

FA.py

Source:FA.py

...101                    msg = '{0}: No return({1})'.format(cmd,loop)102                    print(msg)103            loop = loop + 1104        return(r);105    def _flush(self):106        count = self.__ser.in_waiting107        while (count > 0):108            self.__ser.readline().rstrip()109            count = self.__ser.in_waiting110        return;111    def _set_verbose(self, value):112        self.__verbose = value113        return;114    115    116    def GetAPIVersion(self):117        """Retrieves the API version from the robot118        Returns:119            int: The API version in the robot120        """121        self._flush()122        s = 'GetAPIVersion\n'123        self.__ser.write(s.encode())124        r = self._readval("GetAPIVersion", 1)125        return(r);126        127    def ReadSwitch(self, index):128        """Read the switch value129        Args:130            index: 0 (left) or 1 (right)131        Returns:132            int: 0 (false) or 1 (true)133        """134        self._flush()135        s = 'ReadSwitch {0}\n'.format(int(index))136        self.__ser.write(s.encode())137        r = self._readval("ReadSwitch", 1)138        return(r);139    def ReadIR(self, index):140        """Read the IR value141        Args:142            index: IR sensor to query (0 to 7)143        Returns:144            int: Value of IR sensor (0 to 4095)145        """146        self._flush()147        s = 'ReadIR {0}\n'.format(int(index))148        self.__ser.write(s.encode())149        r = self._readval("ReadIR", 1)150        return(r);151    def ReadLine(self, index):152        """Read the line sensor value153        Args:154            index: Line sensor to query (0 to 1)155        Returns:156            int: Value of Line sensor (0 to 4095)157        """158        self._flush()159        s = 'ReadLine {0}\n'.format(int(index))160        self.__ser.write(s.encode())161        r = self._readval("ReadLine", 1)162        return(r);163    def ReadLight(self):164        """Read the light sensor value165        Returns:166            int: Value of light sensor (0 to 4095)167        """168        self._flush()169        s = 'ReadLight\n'170        self.__ser.write(s.encode())171        r = self._readval("ReadLight", 1)172        return(r);173    def ReadMic(self):174        """Read the microphone sensor value175        Returns:176            int: Value of microphone sensor (0 to 4095)177        """178        self._flush()179        s = 'ReadMic\n'180        self.__ser.write(s.encode())181        r = self._readval("ReadMic", 1)182        return(r);183    def ReadAxis(self, index):184        """Read the axis value of the accelerometer185        Args:186            index: Axis to query (0 to 3)187        Returns:188            int: Value of accelerometer axis (-32768 to 32767)189        """190        self._flush()191        s = 'ReadAxis {0}\n'.format(int(index))192        self.__ser.write(s.encode())193        r = self._readval("ReadAxis", 1)194        return(r);195    def SetMotors(self, left, right):196        """Set the motors speed197        Args:198            left: value of left motor (0 to 100)199            right: value of right motor (0 to 100)200        """201        s = 'SetMotors {0} {1}\n'.format(int(left),int(right))202        self.__ser.write(s.encode())203        return;204    def Forwards(self, distance):205        """Set the robot moving forward206        Args:207            distance: distance to move (0 to 1000) in mm208        """209        self._flush()210        s = 'Forwards {0}\n'.format(int(distance))211        self.__ser.write(s.encode())212        timeout = abs(int(distance / 50))213        if (timeout <= 0):214            timeout = 1215        r = self._readval("Forwards", timeout)216        return(r);217    def Backwards(self, distance):218        """Set the robot moving backwards219        Args:220            distance: distance to move (0 to 1000) in mm221        """222        self._flush()223        s = 'Backwards {0}\n'.format(int(distance))224        self.__ser.write(s.encode())225        timeout = abs(int(distance / 50))226        if (timeout <= 0):227            timeout = 1228        r = self._readval("Backwards", timeout)229        return(r);230    def Left(self, angle):231        """Set the robot to turn left232        Args:233            angle: angle to rotate (0 to 360) in degrees234        """235        self._flush()236        s = 'Left {0}\n'.format(int(angle))237        self.__ser.write(s.encode())238        timeout = abs(int(angle / 45))239        if (timeout <= 0):240            timeout = 1241        r = self._readval("Left", timeout)242        return(r);243    def Right(self, angle):244        """Set the robot to turn right245        Args:246            angle: angle to rotate (0 to 360) in degrees247        """248        self._flush()249        s = 'Right {0}\n'.format(int(angle))250        self.__ser.write(s.encode())251        timeout = abs(int(angle / 45))252        if (timeout <= 0):253            timeout = 1254        r = self._readval("Right", timeout)255        return(r);256    257    def LEDWrite(self, value):258        """Set the value of the LEDs259        Args:260            value: Value to set the LEDS (0 to 255)261        """262        s = 'LEDWrite {0}\n'.format(int(value))263        self.__ser.write(s.encode())264        return;265    def LEDOn(self, index):266        """Turn an LED on267        Args:268            index: The LED to turn on (0 to 7)269        """270        s = 'LEDOn {0}\n'.format(int(index))271        self.__ser.write(s.encode())272        return;273    def LEDOff(self, index):274        """Turn an LED off275        Args:276            index: The LED to turn off (0 to 7)277        """278        s = 'LEDOff {0}\n'.format(int(index))279        self.__ser.write(s.encode())280        return;281    def PlayNote(self, note, length):282        """Play a note on the speaker283        Args:284            note: The frequency of the note (1 to 10000) in Hz285            length: The duration of the note (1 to 10000) in ms286        """287        s = 'PlayNote {0} {1}\n'.format(int(note),int(length))288        self.__ser.write(s.encode())289        time.sleep(length/1000)290        return;291        292    def GetBattery():293        s = 'GetBattery\n'294        self.__ser.write(s.encode())295        r = self._readval("Battery", timeout)296        return(r);297    298    def ExpDDR(bitnumber,direction):299        s = 'ExpDDR {0} {1}\n'.format(bitnumber,direction)300        self.__ser.write(s.encode())301        return;302     303    def ExpRead(bitnumber):304        s = 'ExpRead {0}\n'.format(bitnumber)305        self.__ser.write(s.encode())306        r = self._readval("Bit", timeout)307        return(r);308        309    def ExpWrite(bitnumber,value):310        s = 'ExpWrite {0} {1}\n'.format(bitnumber,value)311        self.__ser.write(s.encode())312        return;313        314    def ExpAn(annumber):315        s = 'ExpAn {0}\n'.format(annumber)316        self.__ser.write(s.encode())317        r = self._readval("An", timeout)318        return(r);319##    #blocking...320##    def PlayNote(self, note, time):321##        self._flush()322##        s = 'PlayNote {0} {1}\n'.format(int(note),int(time))323##        self.__ser.write(s.encode())324##        timeout = abs(int(time / 1000))325##        if (timeout <= 0):326##            timeout = 1327##        r = self._readval("PlayNote", timeout)328##        return;329    def ServoEnable(self, index):330        """Enable a servo motor331        Args:332            index: The servo to control (0 to 3)333        """334        s = 'ServoEnable {0}\n'.format(int(index))335        self.__ser.write(s.encode())336        return;337    def ServoDisable(self, index):338        """Disable a servo motor339        Args:340            index: The servo to control (0 to 3)341        """342        s = 'ServoDisable {0}\n'.format(int(index))343        self.__ser.write(s.encode())344        return;345    def ServoSetPos(self, index, position):346        """Move a servo immediately to a position347        Args:348            index: The servo to control (0 to 3)349            position: The position of the servo (0 to 255)350        """351        s = 'ServoSetPos {0} {1}\n'.format(int(index),int(position))352        self.__ser.write(s.encode())353        return;354    def ServoAutoMove(self, index, position):355        """Auto-move a servo to a position356        Args:357            index: The servo to control (0 to 3)358            position: The position of the servo (0 to 255)359        """360        s = 'ServoAutoMove {0} {1}\n'.format(int(index),int(position))361        self.__ser.write(s.encode())362        return;363    def ServoMoveSpeed(self, speed):364        """Set the auto-move speed365        Args:366            speed: The servo speed (1 to 50)367        """368        s = 'ServoMoveSpeed {0}\n'.format(int(speed))369        self.__ser.write(s.encode())370        return;371    def LCDClear(self):372        """Clear the LCD373        """374        s = 'LCDClear\n'375        self.__ser.write(s.encode())376        return;377    def LCDPrint(self, x, y, text):378        """Display text on the LCD379        Args:380            x: The x-coordinate (0 to 127)381            y: The y-coordinate (0 to 31)382            text: The text to display383        """384        s = 'LCDPrint {0} {1} {2}\n'.format(int(x),int(y),text)385        self.__ser.write(s.encode())386        return;387    def LCDNumber(self, x, y, value):388        """Display a number on the LCD389        Args:390            x: The x-coordinate (0 to 127)391            y: The y-coordinate (0 to 31)392            value: The number to display (-32768 to 32767)393        """394        s = 'LCDNumber {0} {1} {2}\n'.format(int(x),int(y),int(value))395        self.__ser.write(s.encode())396        return;397    def LCDPixel(self, x, y, state):398        """Display a pixel on the LCD399        Args:400            x: The x-coordinate (0 to 127)401            y: The y-coordinate (0 to 31)402            state: 0 (off) or 1 (on)403        """404        s = 'LCDPixel {0} {1} {2}\n'.format(int(x),int(y),int(state))405        self.__ser.write(s.encode())406        return;407    def LCDLine(self, x1, y1, x2, y2):408        """Display a line on the LCD between points A and B409        Args:410            x1: The x-coordinate of point A (0 to 127)411            y1: The y-coordinate of point A (0 to 31)412            x2: The x-coordinate of point B (0 to 127)413            y2: The y-coordinate of point B (0 to 31)414        """415        s = 'LCDLine {0} {1} {2} {3}\n'.format(int(x1),int(y1),int(x2),int(y2))416        self.__ser.write(s.encode())417        return;418    def LCDRect(self, x1, y1, x2, y2):419        """Display a rectangle on the LCD between points A and B420        Args:421            x1: The x-coordinate of point A (0 to 127)422            y1: The y-coordinate of point A (0 to 31)423            x2: The x-coordinate of point B (0 to 127)424            y2: The y-coordinate of point B (0 to 31)425        """426        s = 'LCDRect {0} {1} {2} {3}\n'.format(int(x1),int(y1),int(x2),int(y2))427        self.__ser.write(s.encode())428        return;429    def LCDBacklight(self, value):430        """Control the backlight of the display431        Args:432            value: The brightness of the backlight (0 to 100)433        """434        s = 'LCDBacklight {0}\n'.format(int(value))435        self.__ser.write(s.encode())436        return;437    def LCDOptions(self, foreground, background, transparent):438        """Set the options for the display439        Args:440            foreground: The foreground colour, 0 (white) or 1 (black)441            background: The background colour, 0 (white) or 1 (black)442            transparent: The transparency, 0 (false) or 1 (true)443        """444        s = 'LCDOptions {0} {1} {2}\n'.format(int(foreground), int(background), int(transparent))445        self.__ser.write(s.encode())446        return;447    def _LCDVerbose(self, value):448        s = 'LCDVerbose {0}\n'.format(int(value))449        self.__ser.write(s.encode())450        return;451    def CardInit(self):452        self._flush()453        s = 'CardInit\n'454        self.__ser.write(s.encode())455        r = self._readval("CardInit", 2)456        return(r);457    def CardCreate(self, filename):458        self._flush()459        s = 'CardCreate {0}\n'.format(filename)460        self.__ser.write(s.encode())461        r = self._readval("CardCreate", 2)462        return(r);463    def CardOpen(self, filename):464        self._flush()465        s = 'CardOpen {0}\n'.format(filename)466        self.__ser.write(s.encode())467        r = self._readval("CardOpen", 2)468        return(r);469    def CardDelete(self, filename):470        self._flush()471        s = 'CardDelete {0}\n'.format(filename)472        self.__ser.write(s.encode())473        r = self._readval("CardDelete", 2)474        return(r);475    def CardWriteByte(self, data):476        #self._flush()477        s = 'CardWriteByte {0}\n'.format(int(data))478        self.__ser.write(s.encode())479        #r = self._readval("CardWriteByte", 2)480        return();481    def CardReadByte(self):482        self._flush()483        s = 'CardReadByte\n'484        self.__ser.write(s.encode())485        r = self._readval("CardReadByte", 2)486        return(r);487    def CardRecordMic(self, bitdepth, samplerate, time, filename):488        self._flush()489        s = 'CardRecordMic {0} {1} {2} {3}\n'.format(int(bitdepth),int(samplerate),int(time),filename)490        self.__ser.write(s.encode())491        r = self._readval("CardRecordMic", time+1)492        return(r);493    def CardPlayback(self, filename):494        self._flush()495        s = 'CardPlayback {0}\n'.format(filename)496        self.__ser.write(s.encode())497        r = self._readval("CardPlayback", 50)498        return(r);499    def CardBitmap(self, x, y, filename):500        self._flush()501        s = 'CardBitmap {0} {1} {2}\n'.format(int(x),int(y),filename)502        self.__ser.write(s.encode())503        r = self._readval("CardBitmap", 5)504        return(r);...

RT_IB.py

Source:RT_IB.py

...102                    msg = '{0}: No return({1})'.format(cmd,loop)103                    print(msg)104            loop = loop + 1105        return(r);106    def _flush(self):107        count = self.__ser.in_waiting108        while (count > 0):109            self.__ser.readline().rstrip()110            count = self.__ser.in_waiting111        return;112    def _set_verbose(self, value):113        self.__verbose = value114        return;115    def ADCSample8(self, channel):116        """Reads an analogue value from a pin as an 8-bit value117        Args:118            channel: The pin to read to (0 to 2)119        Returns:120            The voltage of the pin (0 to 255)121        """122        self._flush()123        values = bytearray([0x9B, channel, 0])124        self.__ser.write(values)125        values = self.__ser.read(3)126        return(values[2]);127    def ADCSample10(self, channel):128        """Reads an analogue value from a pin as a 10-bit value129        Args:130            channel: The pin to read to (0 to 2)131        Returns:132            The voltage of the pin (0 to 1023)133        """134        self._flush()135        values = bytearray([0x9C, channel, 0, 0])136        self.__ser.write(values)137        values = self.__ser.read(4)138        r = (values[2] * 256) + values[3]139        return(r);140    def DACDisable(self):141        """Disables the DAC output142        143        """144        self._flush()145        values = bytearray([0x9E])146        self.__ser.write(values)147        values = self.__ser.read(1)148        return;149    def DACEnable(self):150        """Enables the DAC output151        152        """153        self._flush()154        values = bytearray([0x9D])155        self.__ser.write(values)156        values = self.__ser.read(1)157        return;158    def DACOutput(self, value):159        """Writes a 5-bit value to the DAC output160        161        Args:162            value: The value to write to (0 to 31)163        164        """165        self._flush()166        values = bytearray([0x9F, value])167        self.__ser.write(values)168        values = self.__ser.read(2)169        return;170    def I2CInitialise(self):171        """Enables the I2C interface172        173        """174        self._flush()175        values = bytearray([0x86])176        self.__ser.write(values)177        values = self.__ser.read(1)178        return;179    def I2CReceive(self, last):180        """Reads an byte from the I2C interface181        182        Args:183            last: The last byte to read? (0 to 1)184        Returns:185            The received value (0 to 255)186        """187        self._flush()188        values = bytearray([0x8B, last, 0])189        self.__ser.write(values)190        values = self.__ser.read(3)191        return(values[2]);192    def I2CRestart(self):193        """Restarts the I2C interface194        195        """196        self._flush()197        values = bytearray([0x88])198        self.__ser.write(values)199        values = self.__ser.read(1)200        return;201    def I2CSend(self, data):202        """Sends a byte to the I2C interface203        Args:204            data: The last byte to send (0 to 255)205        Returns:206            The ack value (0 to 1)207        """208        self._flush()209        values = bytearray([0x8A, data, 0])210        self.__ser.write(values)211        values = self.__ser.read(3)212        return(values[2]);213    def I2CStart(self):214        """Starts the I2C interface215        216        """217        self._flush()218        values = bytearray([0x87])219        self.__ser.write(values)220        values = self.__ser.read(1)221        return;222    def I2CStop(self):223        """Stops the I2C interface224        225        """226        self._flush()227        values = bytearray([0x89])228        self.__ser.write(values)229        values = self.__ser.read(1)230        return;231    def IOGetInputPin(self, pin):232        """Reads a value from a pin233        Args:234            pin: The pin to write to (0 to 17)235        Returns:236            The state of the pin (0 to 1)237        """238        self._flush()239        values = bytearray([0x81, pin, 0])240        self.__ser.write(values)241        values = self.__ser.read(3)242        return(values[2]);243    def IOSetOutputPin(self, pin, state):244        """Write a value to a pin245        Args:246            pin: The pin to write to (0 to 17)247            state: The value to output (0 to 1)248        """249        self._flush()250        values = bytearray([0x80, pin, state])251        self.__ser.write(values)252        self.__ser.read(3)253        return;   254    def PWMDisable(self, channel):255        """Disables one of the PWM output channels256        Args:257            channel: The PWM channel to disable (0 to 1)258        """259        self._flush()260        values = bytearray([0x93, channel])261        self.__ser.write(values)262        values = self.__ser.read(2)263        return;264    def PWMEnable(self, channel):265        """Enables one of the PWM output channels266        Args:267            channel: The PWM channel to enable (0 to 1)268        """269        self._flush()270        values = bytearray([0x92, channel])271        self.__ser.write(values)272        values = self.__ser.read(2)273        return;274    def PWMSetDuty8(self, channel, value):275        """Sets the duty one of the PWM output channels as an 8-bit value276        Args:277            channel: The PWM channel to enable (0 to 1)278            value: The duty of the PWM channel (0 to 255)279        """280        self._flush()281        values = bytearray([0x95, channel, value])282        self.__ser.write(values)283        values = self.__ser.read(3)284        return;285    def PWMSetDuty10(self, channel, value):286        """Sets the duty one of the PWM output channels as a 10-bit value287        Args:288            channel: The PWM channel to enable (0 to 1)289            value: The duty of the PWM channel (0 to 1023)290        """291        lsb = value & 255 292        msb = value / 256293        self._flush()294        values = bytearray([0x96, channel, lsb, msb])295        self.__ser.write(values)296        values = self.__ser.read(4)297        return;298    def PWMSetPrescaler(self, scaler):299        """Sets the prescaler of the PWM output channels300        Args:301            scaler: The scaler of the PWM channels (0 to 3) 0=1:1 1=1:4 2=1:16 3=1:64302        """303        self._flush()304        values = bytearray([0x94, scaler])305        self.__ser.write(values)306        values = self.__ser.read(2)307        return;308    def SPIInitialise(self):309        """Enables the SPI interface310        311        """312        self._flush()313        values = bytearray([0x82])314        self.__ser.write(values)315        values = self.__ser.read(1)316        return;317    def SPIPrescaler(self, scaler):318        """Sets the prescaler of the SPI interface319        Args:320            scaler: The scaler of the SPI interface (0 to 2) 0=1:1 1=1:4 2=1:16321        """322        self._flush()323        values = bytearray([0x85, scaler])324        self.__ser.write(values)325        values = self.__ser.read(2)326        return;327    def SPITransfer(self, data):328        """Reads and writes a byte on the SPI interface329        Args:330            data: The data byte to send (0 to 255)331            332        Returns:333            The received value (0 to 255)334        """335        self._flush()336        values = bytearray([0x83, data, 0])337        self.__ser.write(values)338        values = self.__ser.read(3)339        return(values[2]);340    def ServoDisable(self, channel):341        """Disables one of the Servo output channels342        Args:343            channel: The Servo channel to disable (0 to 5)344        """345        self._flush()346        values = bytearray([0x98, channel])347        self.__ser.write(values)348        values = self.__ser.read(2)349        return;350    def ServoEnable(self, channel):351        """Enables one of the Servo output channels352        Args:353            channel: The Servo channel to enable (0 to 5)354        """355        self._flush()356        values = bytearray([0x97, channel])357        self.__ser.write(values)358        values = self.__ser.read(2)359        return;360    def ServoSetPosition8(self, channel, position):361        """Sets the position one of the servo output channels as an 8-bit value362        Args:363            channel: The Servo channel to enable (0 to 1)364            position: The position of the Servo channel (0 to 255)365        """366        self._flush()367        values = bytearray([0x99, channel, position])368        self.__ser.write(values)369        values = self.__ser.read(3)370        return;371    def ServoSetPosition16(self, channel, position):372        """Sets the position one of the servo output channels as an 16-bit value373        Args:374            channel: The Servo channel to enable (0 to 1)375            position: The position of the Servo channel (0 to 65535)376        """377        lsb = position & 255 378        msb = position / 256379        self._flush()380        values = bytearray([0x9A, channel, lsb, msb])381        self.__ser.write(values)382        values = self.__ser.read(4)383        return;384    def UARTBaud(self, rate):385        """Sets the baud rate of the UART interface386        Args:387            rate: The baud rate of the UART interface (0 to 7) 0=1200, 1=2400, 2=4800, 3=9600, 4=19200, 5=38400, 6=57600, 7=115200388        """389        self._flush()390        values = bytearray([0x91, rate])391        self.__ser.write(values)392        values = self.__ser.read(2)393        return;394    def UARTInitialise(self):395        """Enables the UART interface396        397        """398        self._flush()399        values = bytearray([0x8D])400        self.__ser.write(values)401        values = self.__ser.read(1)402        return;403    def UARTReceive(self):404        """Reads a byte from the UART receive buffer405            406        Returns:407            The received value (0 to 255)408        """409        self._flush()410        values = bytearray([0x90, 0])411        self.__ser.write(values)412        values = self.__ser.read(2)413        return(values[1]);414    def UARTReceiveCount(self):415        """Reads the number of bytes stored in the UART receive buffer416            417        Returns:418            The received value (0 to 255)419        """420        self._flush()421        values = bytearray([0x8F, 0])422        self.__ser.write(values)423        values = self.__ser.read(2)424        return(values[1]);425    def UARTTransmit(self, data):426        """writes a byte to the UART interface427        Args:428            data: The data byte to send (0 to 255)429            430        """431        self._flush()432        values = bytearray([0x8E, data])433        self.__ser.write(values)434        values = self.__ser.read(2)...

translator-gulp.js

Source:translator-gulp.js

1var File = require('vinyl');2var through = require('through2');3var assert = require('assert');4var Stream = require('stream');5var gulpTranslator = require('../translator-gulp.js');6describe('gulp-translator', function() {7  describe('with null contents', function() {8    it('should let null files pass through', function(done) {9      var translator = gulpTranslator('./test/locales/en.yml');10      var n = 0;11      var _transform = function(file, enc, callback) {12        assert.equal(file.contents, null);13        n++;14        callback();15      };16      var _flush = function(callback) {17        assert.equal(n, 1);18        done();19        callback();20      };21      var t = through.obj(_transform, _flush);22      translator.pipe(t);23      translator.end(new File({24        contents: null25      }));26    });27  });28  describe('with buffer contents', function() {29    it('should interpolate strings  from *.yml locale file - ENGLISH', function(done) {30      var translator = gulpTranslator('./test/locales/en.yml');31      var n = 0;32      var content = new Buffer("{{ user.title | translate }} {{title | translate}}");33      var translated =  "ENGLISH USER TITLE Title";34      var _transform = function(file, enc, callback) {35        assert.equal(file.contents.toString('utf8'), translated);36        n++;37        callback();38      };39      var _flush = function(callback) {40        assert.equal(n, 1);41        done();42        callback();43      };44      var t = through.obj(_transform, _flush);45      translator.pipe(t);46      translator.end(new File({47        contents: content48      }));49    });50    it('should interpolate strings  from *.yml locale file - POLISH', function(done) {51      var translator = gulpTranslator('./test/locales/pl.yml');52      var n = 0;53      var content = new Buffer("{{ user.title | translate }} {{title | translate}}");54      var translated = "POLSKI TYTUL Tytul";55      var _transform = function(file, enc, callback) {56        assert.equal(file.contents.toString('utf8'), translated);57        n++;58        callback();59      };60      var _flush = function(callback) {61        assert.equal(n, 1);62        done();63        callback();64      };65      var t = through.obj(_transform, _flush);66      translator.pipe(t);67      translator.end(new File({68        contents: content69      }));70    });71    it('should interpolate strings from *.json locale file - RUSSIAN', function(done) {72      var translator = gulpTranslator('./test/locales/ru.json');73      var n = 0;74      var content = new Buffer("{{ user.title | translate }} {{title | translate}}");75      var translated = "Ð Ð£Ð¡Ð¡ÐÐÐ ÐÐÐÐÐÐÐÐÐ ÐÐ°Ð³Ð¾Ð»Ð¾Ð²Ð¾Ðº";76      var _transform = function(file, enc, callback) {77        assert.equal(file.contents.toString('utf8'), translated);78        n++;79        callback();80      };81      var _flush = function(callback) {82        assert.equal(n, 1);83        done();84        callback();85      };86      var t = through.obj(_transform, _flush);87      translator.pipe(t);88      translator.end(new File({89        contents: content90      }));91    });92    it("should throw error about undefined locale", function(done){93      var translator = gulpTranslator('./test/locales/pl.yml');94      var n = 0;95      var content = new Buffer("{{ unsupported | translate }}");96      var _transform = function(file, enc, callback) {97        n++;98        callback();99      };100      var _flush = function(callback) {101        assert.equal(n, 0);102        callback();103      };104      translator.on('error', function(err){105        assert.equal(err.message,106          'Error: No such content (unsupported) in locale file and is used in /path');107        done();108      });109      var t = through.obj(_transform, _flush);110      translator.pipe(t);111      translator.end(new File({112        path: '/path',113        contents: content114      }));115    });116    describe('filters', function() {117      it("should lowecase translated text", function(done){118        var translator = gulpTranslator('./test/locales/en.yml');119        var n = 0;120        var content = new Buffer("{{ title | translate }} {{title | translate | lowercase}}");121        var translated = "Title title";122        var _transform = function(file, enc, callback) {123          assert.equal(file.contents.toString('utf8'), translated);124          n++;125          callback();126          done();127        };128        var _flush = function(callback) {129          assert.equal(n, 1);130          callback();131        };132        var t = through.obj(_transform, _flush);133        translator.pipe(t);134        translator.end(new File({135          contents: content136        }));137      });138      it("should uppercase translated text", function(done){139        var translator = gulpTranslator('./test/locales/en.yml');140        var n = 0;141        var content = new Buffer("{{ title | translate }} {{title | translate | uppercase}}");142        var translated = "Title TITLE";143        var _transform = function(file, enc, callback) {144          assert.equal(file.contents.toString('utf8'), translated);145          n++;146          callback();147        };148        var _flush = function(callback) {149          assert.equal(n, 1);150          done();151          callback();152        };153        var t = through.obj(_transform, _flush);154        translator.pipe(t);155        translator.end(new File({156          contents: content157        }));158      });159      it("should capitalize translated text", function(done){160        var translator = gulpTranslator('./test/locales/en.yml');161        var n = 0;162        var content = new Buffer("{{ title | translate }} {{user.title | translate | capitalize}}");163        var translated = "Title English user title";164        var _transform = function(file, enc, callback) {165          assert.equal(file.contents.toString('utf8'), translated);166          n++;167          callback();168          done();169        };170        var _flush = function(callback) {171          assert.equal(n, 1);172          callback();173        };174        var t = through.obj(_transform, _flush);175        translator.pipe(t);176        translator.end(new File({177          contents: content178        }));179      });180      it("should capitalize every word in translated text", function(done){181        var translator = gulpTranslator('./test/locales/en.yml');182        var n = 0;183        var content = new Buffer("{{ title | translate }} {{user.title | translate | capitalizeEvery}}");184        var translated = "Title English User Title";185        var _transform = function(file, enc, callback) {186          assert.equal(file.contents.toString('utf8'), translated);187          n++;188          callback();189          done();190        };191        var _flush = function(callback) {192          assert.equal(n, 1);193          callback();194        };195        var t = through.obj(_transform, _flush);196        translator.pipe(t);197        translator.end(new File({198          contents: content199        }));200      });201      it("should reverse translated text", function(done){202        var translator = gulpTranslator('./test/locales/en.yml');203        var n = 0;204        var content = new Buffer("{{ title | translate }} {{user.title | translate | reverse}}");205        var translated = "Title ELTIT RESU HSILGNE";206        var _transform = function(file, enc, callback) {207          assert.equal(file.contents.toString('utf8'), translated);208          n++;209          callback();210          done();211        };212        var _flush = function(callback) {213          assert.equal(n, 1);214          callback();215        };216        var t = through.obj(_transform, _flush);217        translator.pipe(t);218        translator.end(new File({219          contents: content220        }));221      });222      it("should throw error if unsupported filter", function(done){223        var translator = gulpTranslator('./test/locales/en.yml');224        var n = 0;225        var content = new Buffer("{{ title | translate }} {{title | translate | unsupported}}");226        var _transform = function(file, enc, callback) {227          assert.equal(file.contents.toString('utf8'), translated);228          n++;229          callback();230        };231        var _flush = function(callback) {232          assert.equal(n, 0);233          callback();234        };235        translator.on('error', function(err){236          assert.equal(err.message, 'Error: unsupported filter is not supported and is used in /path');237          done();238        });239        var t = through.obj(_transform, _flush);240        translator.pipe(t);241        translator.end(new File({242          path: '/path',243          contents: content244        }));245      });246    });247  });248  describe('with stream contents', function() {249    it('should emit errors', function(done) {250      var translator = gulpTranslator('./test/locales/en.yml');251      var content = Readable("{{ title }} {{title}}");252      var n = 0;253      var _transform = function(file, enc, callback) {254        n++;255        callback();256      };257      var _flush = function(callback) {258        assert.equal(n, 0);259        callback();260      };261      translator.on('error', function(err){262        assert.equal(err.message, "Streaming not supported");263        done();264      });265      var t = through.obj(_transform, _flush);266      translator.pipe(t);267      translator.end(new File({268        contents: content269      }));270    });271  });272});273function Readable(content, cb){274  var readable = new Stream.Readable();275  readable._read = function() {276    this.push(new Buffer(content));277    this.push(null); // no more data278  };279  if (cb) readable.on('end', cb);280  return readable;...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.