tb Class
Constructor
tb
-
pOptions
Parameters:
-
pOptions
Object-
pClass
- class Namespace as string or class
-
[pConfig]
optional- optional configuration, any type, preferrably object
-
[pTarget]
optional- target to put object in, DOM node or any other object
-
Returns:
Example:
// put Instance into DOM node
new tb(
app.myConstructor, // any constructor you want to have an instance of
{ ... }, // the config object you hand over to the constructor
target.appendChild( document.createElement( 'span' ) ) // DOM node to insert the object item
);
// put Instance anywhere
new tb(
app.myConstructor, // any constructor you want to have an instance of
{ ... }, // the config object you hand over to the constructor
anotherTbInstance // any other object you want to put the tb instance in
);
// if a namespace STRING is given, requirement loading is done in case the class isnt present yet
new tb(
'app.myConstructor', // namespace string for the constructor you want to have an instance of
{ ... }, // the config object you hand over to the constructor
anotherTbInstance // any other object you want to put the tb instance in
);
Item Index
Methods
- add
- children
- concat
- descendants
- every
- filter
- first
- flush
- forEach
- indexOf
- last
- map
- next
- not
- off
- on
- one
- parent
- parents
- pop
- prev
- push
- reduce
- reduceRight
- reverse
- shift
- slice
- some
- splice
- tb.debounce static
- tb.extend static
- tb.idle static
- tb.observable static
- tb.parse static
- tb.store static
- toArray
- trigger
- unique
- unshift
- walkSelector
Properties
- tb.status static
- tb.status.loadCount
Methods
add
-
[pParam]
Parameters:
-
[pParam]
Object optional- any kind of TbSelector parameter
Returns:
- tb.Selector instance (maybe empty) - for chaining
add() method
add elements to current result set
- return TbSelector result set (unique)
children
-
[pSelector]
-
[pLocalOnly]
Parameters:
Returns:
- tb.Selector instance - for chaining
.children() method
for each this[0...n] or this as tb() instance,
- get all direct children of tb object
- check them against the filter param pSelector
- return TbSelector result set (unique)
descendants
-
[pSelector]
Parameters:
-
[pSelector]
Object optional- any type of tb.Selector parameter
Returns:
- tb.Selector instance - for chaining
.descendants() method
for each this[0...n] or this as tb() instance,
- get all descendants of tb object
- check them against the filter param pSelector
- return TbSelector result set (unique)
filter
-
[pParam]
Parameters:
-
[pParam]
Object optional- any kind of TbSelector parameter
Returns:
- tb.Selector instance (maybe empty) - for chaining
filter() method
for each this[0...n] or this as tb() instance,
- check them against the filter param pParam
- return TbSelector result set (unique)
first
()
Object
chainable
Returns:
- tb.Selector instance (maybe empty) - for chaining
first() method
for each this[0...n] or this as tb() instance,
- get the first child of the tb object parent
- check it against the filter param pSelector
- return TbSelector result set (unique)
flush
()
Object
chainable
Returns:
- mpty tb.Selector instance - for chaining
flush() method
empty current result set
- return empty TbSelector result set
last
()
Object
chainable
Returns:
- tb.Selector instance (maybe empty) - for chaining
last() method
for each this[0...n] or this as tb() instance,
- get the last child of the tb object parent
- check it against the filter param pSelector
- return TbSelector result set (unique)
next
()
Object
chainable
Returns:
- tb.Selector instance (maybe empty) - for chaining
next() method
for each this[0...n] or this as tb() instance,
- get the direct following sibling of tb instance
- check it against the filter param pSelector
- return TbSelector result set (unique)
not
-
[pParam]
Parameters:
-
[pParam]
Object optional- any kind of TbSelector parameter
Returns:
- tb.Selector instance (maybe empty) - for chaining
not() method
for each this[0...n] or this as tb() instance,
- check them against pSelector and remove all that match
- return TbSelector result set (unique)
off
-
pEventName
-
pHandler
Parameters:
Returns:
- tb.Selector instance or tB instance - for chaining
.off() method
removes a handler from a twoBirds instance or a tb.Selector result set afterwards the handler is deleted from the event handler list
on
-
pEventName
-
pHandler
-
[pOnce=false]
Parameters:
Returns:
- tb.Selector instance or tB instance - for chaining
.on() method
adds a handler to a twoBirds instance or a tb.Selector result set
one
-
pEventName
-
pHandler
Parameters:
Returns:
- tb.Selector instance or tB instance - for chaining
.one() method
adds a handler to a twoBirds instance or a tb.Selector result set, to be called only once when the event fires afterwards the handler is deleted from the event handler list
parent
-
[pSelector]
Parameters:
-
[pSelector]
Object optional- any type of tb.Selector parameter
Returns:
- tb.Selector instance - for chaining
.parent() method
for each this[0...n] or this as tb() instance,
- get closest parent tb object
- check all of them against the filter param pSelector
- return TbSelector result set (unique)
parents
-
[pSelector]
Parameters:
-
[pSelector]
Object optional- any type of tb.Selector parameter
Returns:
- tb.Selector instance - for chaining
.parents() method
for each this[0...n] or this as tb() instance,
- get all parent tb objects
- check them against the filter param pSelector
- return them as a TbSelector result set (unique)
prev
()
Object
chainable
Returns:
- tb.Selector instance (maybe empty) - for chaining
prev() method
for each this[0...n] or this as tb() instance,
- get the direct previous sibling of tb instance
- check it against the filter param pSelector
- return TbSelector result set (unique)
tb.debounce
-
pFunction
-
pMilliseconds
debounce function wrapper
Parameters:
Example:
// expect that to be this tb instance
// append a debounced handler to the 'myEvent' event
that.on(
'myEvent',
tb.debounce(
function(){
// that = tb instance
console.log('debounced "myEvent" handler inside', that);
},
500 // milliseconds
)
);
tb.extend
-
pObj
-
[pObj]
- takes any number of objects as parameters
- merges content into the first parameter object
- always a deep copy
Parameters:
-
pObj
Object- object to extend
-
[pObj]
...object optionalany number of other objects to merge in
Returns:
- extended object
tb.idle
-
pCallback
Parameters:
-
pCallback
Functionfunction to execute when all loading is finished
Example:
// in code... tb.idle( function(){ // do whatever you like } );
tb.observable
-
[pStartValue]
tb.observable()) function
- creates a function to set/get the inner value
- initializes the inner value with the parameter given
- returns this function
Parameters:
-
[pStartValue]
optionalinitial content of observable
Returns:
- observableFunction
Example:
// observable data IS NOT an object
var o = tb.observable( 0 ); // numeric
o.observe(
function( pValue ){ // callback will be triggered when observable value changes
console.log( pValue );
},
true // true indicates callback will be called only once
);
o( 5 ); // change observable value
// observable data IS an object
var o = tb.observable( { a: 5 } ); // object
o.observe(
function( pValue ){ // callback will be triggered when observable value changes
console.log( pValue );
},
false // false or no parameter indicates callback will always be called
// when the data changes, true will trigger it only once
);
// get data:
o( 'a' ); // => 5
o(); // => { a: 5 }
// each of these will trigger the callback since the data changed
// also they return the observable itself for chaining purposes, NOT THE VALUE
o( 'a', 6 ); // => { a: 6 }
o( { c: 42 } ); // => { c: 42 }
o( 'b', { c: 42 } ); // => { a: 6, b: { c: 42 } }
tb.parse
-
pWhat
-
pParse
- will replace all matching {namespace1.namespace2.etc} occurrences with values from pParse object
- if typeof pWhat is object or array, it will be done with all strings contained therein and the original pWhat returned
Parameters:
-
pWhat
(string | Object | Array)string, object or array to parse recursively
-
pParse
...objectany number of hash objects containing replacement key/value pairs
Returns:
pWhat parsed
Example:
tb.parse( "{a} test test", { a: 'done' } )
// "done test test"
tb.parse( [ "{a} test test" ], { a: 'done' } )
// ["done test test"]
tb.parse( [ "{a} test test", "{b} test test" ], { a: 'done', b: 'processed' } )
// ["done test test", "processed test test"]
tb.parse( [ "{a} test test", "{b} test test", { g: "another {silly} test" } ], { a: 'done', b: 'processed', silly: 'not so silly' } )
// ["done test test", "processed test test", Object { g="another not so silly test"}]
tb.parse( { a: "{a} test test", b: "{b} test test", c: [ "another {silly} test" ] }, { a: 'done', b: 'processed', silly: 'not so silly' } )
// Object { a="done test test", b="processed test test", c=[ "another not so silly test" ] }
// multiple hash objects:
tb.parse(
"{a} {b}",
{ a: 'done1' },
{ b: 'done2' }
);
// "done1 done2"
tb.store
-
pObj
-
pName
-
pConfig
store function
Parameters:
Returns:
- the store instance
the returned store has one method, .observe( myCallbackFunction )
you can use this method to react on changes in the store
CAVEAT: the store .observe is debounced to accomodate for bulk changes!
Example:
//
// EXAMPLE 1: using late binding
//
tb.store(
that, // the instance
'store', // the property name -> that.store
$( 'form', that.target ).values() // initial values
).bind( // assuming there are some {placeholder}s in that DOM node descendants attributes or text nodes
that.target
);
// any change in the store from now on will update the {placeholder}s
// change complete store:
that.store = {
somePlaceHolder: 'someStringValue'
};
// or a property within the store:
that.store.somePlaceholder = 'someOtherStringValue';
//
// EXAMPLE 2: using the observe function
// expect that to be a tbInstance containing a form
//
tb.store(
that, // the instance
'store', // the property name -> that.store
$( 'form', that.target ).values() // initial values
).observe(
// 1 way data flow
function( pStoreValues ){
// do something with the store values
// e.g. update some part of the DOM
console.log( Object.assign( {}, pStoreValues ) ); // convert to plain object
// other than that you can extract properties like so:
var a = pStoreValues.myProperty;
}
);
// update the store whenever the form values change
// 2 way data binding
$( 'form', that.target )
on(
'change select',
function(ev){
tb.extend(
that.store,
$( 'form', that.target ).values()
);
ev.stopPropagation();
}
);
trigger
-
pEvent
-
[pEventData]
-
[pBubble=l]
Parameters:
Returns:
- tb.Selector instance or tB instance - for chaining
trigger method
triggers an asynchronous twoBirds event, optionally with data and bubble indicator
unique
()
Object
chainable
Returns:
- tb.dom() result set, may be empty
force this tb() result set to be unique
( being called after using methods inherited from array, force uniqueness )


Grant authorizations
Edit (pull request)To grant the authorizations for a platform ADMIN or a user with the APPLICATION_MANAGER role to the given application must go to the target application and click on the button found in the application main page.
Roles information
The available list of roles for the application or its environment and their definition is available at the bottom of this page.
Some roles are specified for the whole application, for example the APPLICATION_MANAGER role and APPLICATION_DEVOPS (they are allowed to the edition and deployment of topologies) are available for the whole application. Some roles, however, such as the deployment role are specified in each environment.
In order to assign a role to a user, just click on the key button on the user row and assign the role of your choice. you can also assign a role to a user group in the same way by going on the Groups tab.
For choosing the roles related to the, just click on the environment dropdown list and select the environment that your need.
Application’s roles
The following roles define the authorized actions which can be executed on a given application :
| Role | Description |
|---|---|
| APPLICATION_MANAGER | Application manager can manage the application configuration, its versions and environments as well as user management for the application. |
| APPLICATION_DEVOPS | Dev ops role should be given to the applications developer. In ALIEN users with devops role on an application can edit the topologies of every SNAPSHOT version. |
Environment’s roles
In addition to the application roles, Application manager can specify some roles related to every single environment defined for the application.
The following roles define the authorized actions which can be executed on a given application :
| Role | Description |
|---|---|
| APPLICATION_USER | An application user on an environment is not only allowed to see the environment status but also has access to the deployment output properties. |
| DEPLOYMENT_MANAGER | Deployment manager for an environment is responsible for the configuration as well as the deployment/undeployment of an environment. In order to be able to deploy/undeploy an environment, the user need to have also a DEPLOYER role on the location where he wants to deploy. DEPLOYER role is configured on the location configuration by any user who has the global ADMIN role. |


You may need to disable Predictive Typing in Android Settings! The WXB screen allows you to file, activate, close, cancel flight plans, and get weather briefings using the Lockheed Martin Flight Services (1-800-WX-BRIEF). All weather briefings are FAA certified, and are recorded in the FAA systems. Please enter accurate information to the best of your knowledge. The plans filed here get into the National Airspace Database under your account on behalf of Apps4Av Inc.
To proceed with plans and briefings, you must create an account with using email , then activate Avare on this website under Account->Service Providers.
To Fill and File the Flight Plan Form
Note: You can enter a plan in the Plan screen, then press the "Prepare" button to let the app fill the form. See Aircraft and Pilot under Preferences for the form fields.
Enter all the mandatory fields in the form. For example, enter Aircraft ID as N172EF, Flight Rule as VFR, Flight Type as General Aviation, No. of Aircraft as 1, Aircraft Type as C172, Wake Turbulence as Light, Aircraft Equipment as S, Departure as KBOS,
Departure Date Time(Zulu) as 2016-01-31 22:30, Cruising Speed in knots as 110, Level as 045, Surveillance Equipment as N, Route as LWM, Destination as KJFK, Total Elapsed Time as 1H30M,
Alternate1 as KTEB, Alternate2 as KMMU, Fuel Endurance as 2H45M, People On Board as 2, Aircraft Color as W/B, Pilot in Command as Charles L, and Pilot Info as Charles L<PHONE_NUMBER>. Note, if a departure/destination ICAO code is not available, enter ZZZZ in requisite field, then enter DEP / DEST in the Other Information Sub-field.
Verify all information, then press the "File Plan" button to file the plan as described by the form.
If the plan is filed, you will receive a success message. The freshly filed plan will appear under the "Filed Plans" list with state PROPOSED.
To Load a Plan
Filed plans can be loaded in the filing form in any state.
Select the plan you want to load in the Filed Plans list by touching on it. The green bar will move to it.
Press the "Load" button, and if the operation is successful, the plan will be loaded in the form as filed.
Note: At this time, loading a filed plan into Plan screen is not supported.
To Amend a Plan
Filed plans can be amended when in PROPOSED state.
Select the plan you want to amend in the Filed Plans list by touching on it. The green bar will move to it.
Load it in the form by following the "To Load a Plan" procedure in this help.
Modify the form as needed.
Press the "Amend" button, and if the operation is successful, the plan will be amended.
To Cancel the Filed Plan
After filing the plan, its state changes to PROPOSED. You can cancel a plan only in PROPOSED state, before it is active.
Select the plan you want to cancel in the Filed Plans list by touching on it. The green bar will move to it.
Press the "Cancel" button, and if the cancel operation is successful, the plan will disappear from the Filed Plans list.
To Activate a Filed Plan
After filing the plan, its state changes to PROPOSED. You can activate a plan only in PROPOSED state.
Select the plan you want to activate in the Filed Plans list by touching on it. The green bar will move to it.
Select the time from now when you will take off from the drop down next to the "Activate Now" button.
Press the "Activate Now" button, and if the activation is successful, the plan's state will change to ACTIVE.
To Close an Active Plan
After activating the plan, its state changes to ACTIVE. You can close a plan only in ACTIVE state.
Select the plan you want to close in the Filed Plans list by touching on it. The green bar will move to it.
If you are overdue, enter the location you are at in the box next to the "Close" button.
Press the "Close" button, and if the close operation is successful, the plan will disappear from the Filed Plans list.
We recommend that you call 1-800-WX-BRIEF to confirm that the plan is closed. If you forget to close an active plan, search and rescue may commence after you are OVERDUE, and you cannot be located.
To Get Plan Briefing
Select the plan you want to get briefing for in the Filed Plans list, by touching on it. The green bar will move to it.
Press the "Get Email Briefing" button once.
The briefing will be emailed to you at the address used for registering with Avare.
Note: Route corridor width of 50 NM is used.
To Get Plan Navigation Log
You can get the navigation logs for an aircraft saved in the aircraft profiles at 1800wxbrief.com.
Select the plan you want to get log for in the Filed Plans list, by touching on it. The green bar will move to it.
Press the "Get Log" button once.
The navigation log will appear at the bottom of the button.
To clear the navigation log, press the "Clear Log" button.
Aircraft Equipment
Warning! You MUST read all information under WXB Help before proceeding.


In the next few pages, we will create several views to make querying the HISTOGRAMBIN_DB2STATISTICS table easier. The HISTOGRAMBIN_DB2STATISTICS table is created when the event monitor DB2STATISTICS is created. Please see the 'Getting Started with Basic Monitoring' tutorial in this workshop for more detail on event monitors.
The first view lists all of the histogram types available. This task reports just the three basic types:lifetime, execution time and queue time.


--- layout: post status: publish published: true title: '"Surrogate Samardzija" - Podcast Episode 6.12' author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 9864 wordpress_url: http://ivyenvy.com/?p=9864 date: '2014-05-04 23:09:06 +0000' date_gmt: '2014-05-05 04:09:06 +0000' categories: - Podcast tags: - Starlin Castro - Anthony Rizzo - Jake Arrieta comments: - id: 10943 author: Jose Corona author_email: '' author_url: '' date: '2014-05-07 12:52:45 +0000' date_gmt: '2014-05-07 17:52:45 +0000' content: Be careful, gentlemen, wouldn't want MLB coming after you guys like Bleacher Nation. http://awfulannouncing.com/2014/mlb-is-urging-itunes-to-pull-team-related-podcasts.html ---
This episode is a milestone for us. This is the 250th episode of The Ivy Envy Podcast. On this episode, Andy, Corey and Kurt talk about the last week in Chicago Cubs baseball. The Cubs seem to be clicking at times and there are some aspects of the team that are encouraging. We mainly talk about Anthony Rizzo, Starlin Castro and some of the pitching.
Jake Arrieta is back from his injury and Andy talks about his first outing in 2014 for the Cubs. There's a pitcher tearing it up in Iowa after struggling in Spring Training. Kurt talks about Wada and we speculate why he might be experiencing so much success at AAA.
There's obviously been a lot of criticism of Cubs ownership and the front office. We talk about Patrick Mooney's piece and try to step out of our front office supporters shoes and look at the things that frustrate some Cubs fans. It seems that these "big picture" topics come up every week.
We answer some listener submitted questions, including some great questions from Dawn about options and Rule 5 players.
Kurt gives us his Scary Stat of the Week early in the episode, we read some Internet Muscle Flexes and we pick a winner for this week's photo caption contest.
We also discussed some upcoming events on this episode:
Ivy Envy Iowa Cubs Game Meet-Up
Wasting Away in Wrigleyville Pub Crawl
If you'd like to fill out a listener survey, we would really appreciate it. Fill it out here: Ivy Envy Listener Survey


Tyler Perry to release his next, A Fall From Grace, on Netflix
A Fall From Grace is about a divorced woman who feels restored by a new romance.
by PTIFilmmaker Tyler Perry is once again collaborating with streamer Netflix on upcoming movie A Fall From Grace.
The writer-director-writer shared the news on Twitter on Saturday, saying the film will debut on streaming platform on January 17.
“My next movie guys!!! This is an amazing thriller!!!” Perry wrote on Twitter alongside a poster of the film.
The thriller will feature Crystal Fox, Phylicia Rashad, Bresha Webb, Cicely Tyson and Perry.
According to Netflix, the story is about a divorced woman who feels restored by a new romance, secrets soon start to erode her short-lived joy.


Encountered error
In order to delete this bin, please specify your api key here (if you do not have one, you can specify it by going to {baseurl}generateApiKey/)
{code_here}


Hunter is a Windows Forensics that you can find it in cyberdefenders.org , this is a walkthrough and how to answer it's questions.
Check it outInjector is a Windows & Memory Forensics that you can find it in cyberdefenders.org , this is a walkthrough and how to answer it's questions.
Check it outHireMe is a Degital Forensics you can find it in cyberdefenders.org , this is a walkthrough and how to answer it's questions.
Check it out


As described in our privacy policy, we use cookies. By continuing to use our Site and/or services, you are agreeing to the use of cookies for the purposes we describe in this policy.
We or our third party service providers use both session ID cookies and persistent cookies on our Site. A session ID cookie expires when you close your browser. Session cookies only last for as long as the session (usually the current visit to a web site or a browser session). A persistent cookie remains on your hard drive for an extended period of time and will be read when you return to the Site.
On our Site, we use certain session cookies to make it easier for you to navigate the Site and making the view of the pages consistent. If you reject cookies, you may still use our Site, but your ability to use some areas of our Site may be limited.
These are the session cookies that we use:
session
_wp_session
PHPSESSID
AWSELB
This is the session cookie that Marketo places:
BIGipServersjlweb-app_http
Information about session cookies that are placed by Marketo can be found at http://www.marketo.com/trust/privacy.php.
Our third party service providers set persistent cookies. This Site uses Google Analytics, a web analytics service provided by Google, Inc. (“Google”). Google Analytics and other third parties, such as Marketo, may track your use of this Site and on other websites and use certain persistent “cookies”, which are text files placed on your computer, to help the website analyze how users use the Site. Information about persistent cookies that are placed by Marketo can be found at http://www.marketo.com/trust/privacy.php. These third-party vendors, including Marketo, use cookies to track your use and identity and to serve ads on other websites and our Site based on a user’s prior visit to our Site.
These are the persistent cookies that Google and/or Marketo set:
_mkto_trk
_ga
_gat
We currently do not track users over time over multiple websites, however, we will abide by browser “Do not Track Signals” from your browser.
Most browsers allow you to control cookies through your setting preferences. If you limit the ability of websites to set cookies, your user experience may be affected. Not allowing cookies may also stop you from saving customized settings like login information.
If you don't want us to use cookies when you visit our Site, you can change your browser settings on your computer or other device you're using to access our Site. If you use our Site without changing your browser settings, we'll assume that you're happy to receive all cookies on the Site.
To find out more about cookies, including how to see what cookies have been set and how to manage and delete them, visit wikipedia.org,www.allaboutcookies.org, or www.aboutcookies.org.
To learn more about third party advertisers' use of cookies the following links are helpful:
Digital Advertising Alliance (EU)
Internet Advertising Bureau (US)
Internet Advertising Bureau (EU)
Network Advertising Initiative


The documents on this site is an invitation for more dialogue. Feel free to fork and make your own branch.
© {{ site.theme.name }}, 2013 —


Organized 3D Point Clouds¶
We demonstrate Polylidar3D being applied to an organized point cloud. Depth images from an Intel RealSense D435i will be processed. This example is taken from the much more thorough script titled realsense_mesh.py
. Refer to that script for more details.
[1]:
import time
import logging
import sys
import os
import json
from IPython.display import Image
SRC_DOCS = os.path.realpath(os.path.join(os.getcwd(), '..', '..', '..', 'src_docs', '_static' ))
sys.path.insert(0, '../../../')
[51]:
import numpy as np
import open3d as o3d
from open3d import JVisualizer
import matplotlib.pyplot as plt
from scipy.spatial.transform import Rotation as R
from examples.python.util.realsense_util import (get_realsense_data, get_frame_data, R_Standard_d400, prep_mesh,
create_open3d_pc, extract_mesh_planes, COLOR_PALETTE)
from polylidar import (Polylidar3D, MatrixDouble, MatrixFloat, extract_tri_mesh_from_float_depth,
extract_point_cloud_from_float_depth)
from polylidar.polylidarutil.open3d_util import construct_grid, create_lines, flatten, create_open_3d_mesh_from_tri_mesh
from polylidar.polylidarutil.plane_filtering import filter_planes_and_holes
from examples.python.realsense_mesh import run_test, callback
First we gather the data and visualize. The point cloud is colored by z-height,the blue points represent the floor of my basement.
[41]:
color_files, depth_files, traj, intrinsics = get_realsense_data()
pcd, rgbd, extrinsics = get_frame_data(4, color_files, depth_files, traj, intrinsics, stride=2)
pcd = pcd.rotate(R_Standard_d400[:3, :3], center=False)
logging.info("File %r - Point Cloud; Size: %r", 4, np.asarray(pcd.points).shape[0])
o3d.visualization.draw_geometries([pcd])
INFO:root:File 4 - Point Cloud; Size: 24817
[42]:
Image(f"{color_files[4]}")
[42]:
[6]:
plt.imshow(np.asarray(rgbd.depth))
[6]:
<matplotlib.image.AxesImage at 0x7f6a2bc62f50>
[7]:
Image(f"{SRC_DOCS}/organized/organized_pc_raw.png")
[7]:
[43]:
run_test(pcd, rgbd, intrinsics, extrinsics, callback=callback, stride=2)
INFO:root:Treated as **Unorganized** Point Cloud - 2.5D Delaunay Triangulation with Polygon Extraction took 14.41 milliseconds
INFO:root:Treated as **Organized** Point Cloud - Right-Cut Triangulation/Uniform Mesh (Mesh only) took 1.71 milliseconds
INFO:root:Polygon Extraction on Uniform Mesh (only one dominant plane normal) took 2.77 milliseconds
This is the result of generating a Right-Cut Triangulaton/Uniform Mesh from the organized point cloud. It only took around a millisecond.
[9]:
Image(f"{SRC_DOCS}/organized/organized_mesh.png")
[9]:
Here is the result of using Polylidar3D to extract planar triangular segments and their polygonal representations which have similar orienation to the floor normal. The basement floor is extracted as a polygon (green line). Notice that there were small holes in the mesh; these were filtered out with the parameter min_hole_vertices
. Notice other planar segments were extracted (purple, red, orange, etc.). These can/were filtered out by either min_triangles
or polygon post-processing with
minimum area requirements.
[10]:
Image(f"{SRC_DOCS}/organized/organized_polygons.png")
[10]:
See realsense_mesh.py
to see how these images are exactly created. However the basics work like this
First create a half-edge triangular mesh of the depth image. Triangles are removed from invalid depth measurements (i.e.., 0).
Call Polylidar3D to extract Planes and Polygons from the mesh.
Filter polygons with polygon post-processing
Note that Polylidar3D can just take an organized point cloud directly if you have it: extract_tri_mesh_from_organized_point_cloud
[11]:
tri_mesh = extract_tri_mesh_from_float_depth(MatrixFloat(
np.asarray(rgbd.depth)), MatrixDouble(np.ascontiguousarray(intrinsics.intrinsic_matrix)), MatrixDouble(extrinsics), stride=2)
num_triangles = np.asarray(tri_mesh.triangles).shape[0]
print(f"Number of triangles: {num_triangles}")
# Create Polylylidar3D object for extraction (you can keep using on more frames later if you desire)
polylidar_kwargs = dict(alpha=0.0, lmax=0.10, min_triangles=100,
z_thresh=0.04, norm_thresh=0.90, norm_thresh_min=0.90, min_hole_vertices=6)
pl = Polylidar3D(**polylidar_kwargs)
planes, polygons = pl.extract_planes_and_polygons(tri_mesh)
num_planes = len(planes)
print(f"Number of planar segments: {len(planes)}")
print(f"Number of polygons : {len(polygons)}")
points = np.asarray(tri_mesh.vertices)
config_pp = dict(filter=dict(hole_area=dict(min=0.025, max=100.0), hole_vertices=dict(min=6), plane_area=dict(min=0.5)),
positive_buffer=0.00, negative_buffer=0.02, simplify=0.01)
polygon_shells, polygons_holes = filter_planes_and_holes(polygons, points, config_pp)
print(f"Number of polygons after filtering: {len(polygon_shells)}")
Number of triangles: 48914
Number of planar segments: 5
Number of polygons : 5
Number of polygons after filtering: 1
Extract Dominant Planes From Organized Point¶
Here we will show another scene where multiple surfaces will be extracted that have different surface normals. Note that you must have FastGA installed as well as OrganizedPointFilters for this example to work.
First lets look at some data I took from an L515 RealSense Sensor in my basement. We will load the depth image, our generated organized point cloud from the depth image, and any meta data we will need.
[69]:
from examples.python.util.realsense_util import REALSENSE_DIR
from pprint import pprint
example_one = 'opc_example_one'
depth_image = np.load(os.path.join(REALSENSE_DIR, example_one, 'L515_Depth.npy'))
with open(os.path.join(REALSENSE_DIR, example_one, 'L515_meta.json')) as f:
meta = json.load(f)
[4]:
print("Depth Intriniscs: ")
pprint(meta['intrinsics'])
Depth Intriniscs:
[[228.90548706054688, 0.0,<PHONE_NUMBER>5585938],
[0.0,<PHONE_NUMBER>2851562, 94.28375244140625],
[0.0, 0.0, 1.0]]
We can convert this depth image into an organized point cloud. This is with the following procedure:
[71]:
intrinsics = np.array(meta['intrinsics'])
extrinsics = np.identity(4)
stride = 1
points = extract_point_cloud_from_float_depth(MatrixFloat(
depth_image), MatrixDouble(intrinsics), MatrixDouble(extrinsics), stride=stride)
new_shape = (int(depth_image.shape[0] / stride), int(depth_image.shape[1] / stride), 3)
opc = np.asarray(points).reshape(new_shape) # organized point cloud (will have NaNs!)
print(opc.shape)
print(opc[:3,:3,:3])
print("Note than any invalid depth measurments (e.g. 0) must be converted to nan values!")
(180, 320, 3)
[[[ nan nan nan]
[ nan nan nan]
[-0.87670461 -0.52191696 1.26800013]]
[[ nan nan nan]
[ nan nan nan]
[-0.87929737 -0.5179085 1.27175009]]
[[ nan nan nan]
[ nan nan nan]
[-0.880853 -0.51326298 1.27400005]]]
Note than any invalid depth measurments (e.g. 0) must be converted to nan values!
Visualize the Raw Organized Point Cloud¶
Look at that beautiful L515 Sensor!
[72]:
# pcd_np = np.array([[0,0,0], [1, 1, 1]])
pcd_np = opc.reshape((opc.shape[0] * opc.shape[1], 3))
pcd_np = pcd_np[~np.isnan(pcd_np).any(axis=1)] # cant have nans in o3d...boooo!!!
pcd = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(pcd_np))
o3d.visualization.draw_geometries([pcd])
[8]:
Image(f"{SRC_DOCS}/organized/l515_opc.png")
[8]:
Smooth Point Cloud and Create Mesh¶
First we need to smooth the point cloud and create a mesh. I have provided a helper module that uses OrganizedPointFilters
to smooth the OPC. It used both Laplacian and Bilateral filtering. The mesh is then created using procedures in Polylidar3D
itself. Here are the parameters:
[7]:
meta['mesh']
[7]:
{'use_cuda': True,
'stride': 1,
'filter': {'loops_laplacian': 1,
'_lambda': 1.0,
'kernel_size': 3,
'loops_bilateral': 3,
'sigma_length': 0.2,
'sigma_angle': 0.15}}
`use_cuda` - Use your GPU for smoothing to make procedures much faster
`loops_laplacian` - how many iterations of Laplacian smoothing
`_lambda` - Weight factor for laplacian smoothing. Leave at 1.0
`kernel_size` - The Laplacian kernel size. Can be 3 or 5. 3 will use get 8 neighbors, 5 will be 27 Neighbors. For very dense point cloud that are very noisy use 5.
`sigma_length` - bilater filtering parameter
`sigma_angle` - bilateral filtering parameter
[73]:
from examples.python.util.helper_mesh import create_meshes_cuda, create_meshes
use_cuda = True
if use_cuda:
mesh, timings = create_meshes_cuda(opc, **meta['mesh']['filter'])
else:
mesh, timings = create_meshes(opc, **meta['mesh']['filter'])
# Note that open3d can not have nan points in its vertices structure (since version 0.10.0), even if the vertices are not used in triangulation,
# must set them to 0 or some finite number, https://github.com/intel-isl/Open3D/issues/1188
mesh_o3d = create_open_3d_mesh_from_tri_mesh(mesh)
o3d.visualization.draw_geometries([mesh_o3d])
[11]:
Image(f"{SRC_DOCS}/organized/l515_mesh_smooth.png")
[11]:
Identify Dominant Plane Normals¶
Now we will use FastGA to identify all the dominant planes. Here are some helper functions:
[32]:
from fastga import GaussianAccumulatorS2, MatX3d, IcoCharts
from fastga.peak_and_cluster import find_peaks_from_ico_charts
def down_sample_normals(triangle_normals, down_sample_fraction=0.12, min_samples=10000, flip_normals=False, **kwargs):
num_normals = triangle_normals.shape[0]
to_sample = int(down_sample_fraction * num_normals)
to_sample = max(min([num_normals, min_samples]), to_sample)
ds_step = int(num_normals / to_sample)
triangle_normals_ds = np.ascontiguousarray(triangle_normals[:num_normals:ds_step, :])
if flip_normals:
triangle_normals_ds = triangle_normals_ds * -1.0
return triangle_normals_ds
def get_image_peaks(ico_chart, ga, level=2,
find_peaks_kwargs=dict(threshold_abs=2, min_distance=1, exclude_border=False, indices=False),
cluster_kwargs=dict(t=0.10, criterion='distance'),
average_filter=dict(min_total_weight=0.01),
**kwargs):
normalized_bucket_counts_by_vertex = ga.get_normalized_bucket_counts_by_vertex(True)
t1 = time.perf_counter()
ico_chart.fill_image(normalized_bucket_counts_by_vertex) # this takes microseconds
# plt.imshow(np.asarray(ico_chart.image))
# plt.show()
peaks, clusters, avg_peaks, avg_weights = find_peaks_from_ico_charts(ico_chart, np.asarray(
normalized_bucket_counts_by_vertex), find_peaks_kwargs, cluster_kwargs, average_filter)
t2 = time.perf_counter()
gaussian_normals_sorted = np.asarray(ico_chart.sphere_mesh.vertices)
return avg_peaks
def extract_all_dominant_plane_normals(tri_mesh, level=5, ga_=None, ico_chart_=None, **kwargs):
triangle_normals = np.asarray(tri_mesh.triangle_normals)
triangle_normals_ds = down_sample_normals(triangle_normals, **kwargs)
triangle_normals_ds_mat = MatX3d(triangle_normals_ds)
ga.integrate(triangle_normals_ds_mat)
avg_peaks = get_image_peaks(
ico_chart, ga, level=level, **kwargs)
ga.clear_count()
return avg_peaks
Please see the FastGA Documentation to understand these parameters
[17]:
meta['fastga']
[17]:
{'level': 4,
'down_sample_fraction': 0.12,
'find_peaks_kwargs': {'threshold_abs': 50,
'min_distance': 1,
'exclude_border': True,
'indices': False},
'cluster_kwargs': {'t': 0.28, 'criterion': 'distance'},
'average_filter': {'min_total_weight': 0.1}}
[33]:
ga = GaussianAccumulatorS2(level=meta['fastga']['level'])
ico_chart = IcoCharts(level=meta['fastga']['level'])
avg_peaks = extract_all_dominant_plane_normals(
mesh, ga_=ga, ico_chart_=ico_chart, **meta['fastga'])
print("The dominant plane surface normals in the sensor frame of refererence: ")
print(avg_peaks)
The dominant plane surface normals in the sensor frame of refererence:
[[ 0. 0.52573111 -0.85065081]
[ 0. -0.85065081 -0.52573111]]
Extract Planes and Polygons with Polylidar3D¶
Once again here is a heper function
[66]:
def filter_and_create_open3d_polygons(points, polygons, rm=None):
" Apply polygon filtering algorithm, return Open3D Mesh Lines "
config_pp = dict(filter=dict(hole_area=dict(min=0.025, max=100.0), hole_vertices=dict(min=6), plane_area=dict(min=0.1)),
positive_buffer=0.00, negative_buffer=0.00, simplify=0.02)
planes, obstacles = filter_planes_and_holes(polygons, points, config_pp, rm)
all_poly_lines = create_lines(planes, obstacles, line_radius=0.01)
return all_poly_lines
[67]:
polylidar_kwargs=dict(alpha=0.0, lmax=0.05, min_triangles=500,
z_thresh=0.15, norm_thresh=0.95, norm_thresh_min=0.95, min_hole_vertices=10, task_threads=4)
pl = Polylidar3D(**polylidar_kwargs)
avg_peaks_mat = MatrixDouble(avg_peaks)
all_planes, all_polygons = pl.extract_planes_and_polygons_optimized(mesh, avg_peaks_mat)
vertices_np = np.asarray(mesh.vertices)
triangles_np = np.asarray(mesh.triangles)
mesh_3d_polylidar = []
for i in range(avg_peaks.shape[0]):
avg_peak = avg_peaks[i, :]
rm, _ = R.align_vectors([[0, 0, 1]], [avg_peak])
all_poly_lines = filter_and_create_open3d_polygons(vertices_np, all_polygons[i], rm)
mesh_3d_polylidar.extend(flatten([line_mesh.cylinder_segments for line_mesh in all_poly_lines]))
o3d.visualization.draw_geometries(
[mesh_o3d, *mesh_3d_polylidar])
[68]:
Image(f"{SRC_DOCS}/organized/l515_polygons.png")
[68]:


SEE SPOT RUN A film review by Norm Schrager Copyright 2001 filmcritic.com filmcritic.com
David Arquette gets to reinforce his status as the goofy doofus once again in this below-average family comedy about a boy, a dog, and a dumb, sloppy, immature mailman (that would be Arquette). Peering through this half-assed attempt at a funny movie, it's easy to see that the laughs are few and the comic action is a bore -- even the dog looks kind of fed up.
 Sure, he's played the part before, but in a film like this, Arquette gets to be genuinely likable, especially in the face of the W.C. Fields edict (never work with dogs or children).
 In short, Arquette's Gordon has to look after his young neighbor (a cute, laid-back kid named Angus T. Jones) after the little guy's beautiful, overbearing mother is stuck trying to return home from a trip (horribly bad shades of Planes, Trains, & Automobiles). While Gordon and the boy get acquainted, they meet up with Agent 11, a sharp FBI dog on the run from unhappy mobsters -- including a slumming, unfunny Paul Sorvino.
Mob guys chase dog.  Mayhem ensues.
With such a thin, familiar plotline, you'd think the writers would get to it. Yet, it takes more than a half-hour for the two stories to collide. If this movie was made with kids in mind, director John Whitesell (helming his first feature) and company sure do try the youngsters' collective patience.
The action sequences play like Home Alone meets Baby's Day Out, as directed by a guy with no experience handling things like slapstick and moving cars. The scenes look stagy and awkward, and in the long run all the gags just seem kind of tame. Of course, the more static laughs run to flatulence and poop, but I guess that's pretty harmless (if not, uncreative) when it comes to entertaining kids.
And speaking of harmless, I never really got the feeling that this dog could cause too much trouble. In fact, the plot provides a backstory showing the serious pooch as a pup, being instructed to work and not have fun. So, as an adult, he doesn't fetch or play catch. He just sits there. Like this movie.
David Arquette should continue to head for more all-family comedies as a career angle, but as for this one -- you'll be longing for Turner and Hooch.
RATING: **
|------------------------------| \ ***** Perfection \ \ **** Good, memorable film \ \ *** Average, hits and misses \ \ ** Sub-par on many levels \ \ * Unquestionably awful \ |------------------------------|
MPAA Rating: PG
Director: John Whitesell Producers: Robert Simonds, Tracey Trench, Andrew Deane Writers: Daniel Baron, Christopher Faber Starring: David Arquette, Angus T. Jones, Anthony Anderson, Michael Clarke Duncan, Leslie Bibb, Kim Hawthorne, Constance Marie, Steven R. Schirripa, Paul Sorvino, Joe Viterelli
http://www.see-spot-run.com/
--- http://www.amazon.com/exec/obidos/redirect?tag=filmcriticcom&path=subst/video/sellers/amazon-top-100-dvd.html Movie Fiends: Check out Amazon.com's Top 100 Hot DVDs!
Visit filmcritic.com on the Web at http://www.filmcritic.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


RedseaTel
13:37
Super Great Song 2
Bestest Artist
▶
Good Riddance
Green Day
⏸
What's Going On
Marvin Gaye
▶
Dancing Queen
ABBA
▶
Follow You
Imagine Dragons
▶
Circles
Post Malone
▶


Occasions
Jump start search by selecting the event you're shopping for.
Questionnaire
Narrow down your options by answering the following questions about the gift receiver.
Gift Options
Etsy
eBay
Amazon


Hello World!
Servlet1 (in web.xml)
Servlet2
Servlet3
Servlet4
Servlet5
Annotated Servlet10
Annotated Servlet11
Annotated Servlet12
Annotated Servlet13
Annotated Servlet14
Annotated Servlet15


There are many ways to get started with Travel Simulator and this page is here to give you all the information you need to do so easily.
Choosing which flavor is the right for you is pretty easy. If you are looking to use Travel Simulator as soon as possible in a preconfigured environment you can go to the online version or download the preconfigured virtual machine and import it into Virtual Box. If your goal is to have the most amount of fun, start contributing or simply dig deep into Travel Simulator, you can get the source code on Github.
Travel Simulator comes in different flavors :
All simulator modules are available as RPM packages. Do not hesitate to check for the needed packages on the linux packages search page. Follow the steps below to learn how to download and install those packages within one of the following Linux environment:
Linux users take advantage of the 'yum' command to search, install or update RPM packages:
yum search <module_name> yum install <module_name> yum update <module_name>
For instance, let's install the trademgen module in charge of the demand generation. Here is a list of the available trademgen packages. Try:
yum search trademgen
yum install trademgen
Good to notice! All trademgen dependencies (i.e. stdair and sevmgr) have been automatically installed too.
Finally, check that the installation has been successful by displaying the help of the trademgen module:
trademgen -h
First of all, you need to install and set up git within your working Linux/Unix environment.
If you are only interested by a specific module, or by individual component packages, you can find the module by module installation guide below.
Enter the chosen working directory, for instance:
mkdir -p ~/dev/sim
cd ~/dev/sim
Clone the metasim project from the github environment:
git clone git@github.com:airsim/metasim.git metasimgit
cd metasimgit
Copy and edit the metasim.yaml file with your own details (check you firewall settings if necessary):
cp metasim.yaml.sample metasim.yamlAdapt metasim.yaml to your environment. In particular, you may turn off the 64bit library option as well as the generation of the GCOV/LCOV tests and of the documentation:
cmake_args: '-DCMAKE_BUILD_TYPE:STRING=Debug -DINSTALL_DOC:BOOL=OFF \The avlcal and simlfs are not currently used; so they can be dropped without any other consequence.
-DENABLE_TEST:BOOL=ON -DRUN_GCOV:BOOL=OFF'
After editing the metasim.yaml file, it should look like:
# MetaSim configuration file default_base_repo: 'git@github.com:airsim' default_branch: trunk cmake_args: '-DCMAKE_BUILD_TYPE:STRING=Debug -DINSTALL_DOC:BOOL=OFF \
-DENABLE_TEST:BOOL=ON -DRUN_GCOV:BOOL=OFF' publish_path: /dev/sim/metasimgit components: - name: tvlsim repo: 'https://github.com/airsim/tvlsim.git' deps: [stdair, airrac, rmol, airinv, simfqt, airsched, simcrs, trademgen, sevmgr, travelccm] - name: simcrs repo: 'https://github.com/airsim/simcrs.git' deps: [stdair, airrac, rmol, sevmgr, airinv, simfqt, airsched] - name: simlfs repo: 'https://github.com/airsim/simlfs.git' deps: [stdair, airrac, rmol, sevmgr, airinv, simfqt] - name: avlcal repo: 'https://github.com/airsim/avlcal.git' deps: [stdair, airrac, rmol, airinv] - name: airinv repo: 'https://github.com/airsim/airinv.git' deps: [stdair, airrac, rmol, sevmgr] - name: trademgen repo: 'https://github.com/airsim/trademgen.git' deps: [stdair, sevmgr] - name: rmol repo: 'https://github.com/airsim/rmol.git' deps: [stdair, airrac] - name: simfqt repo: 'https://github.com/airsim/simfqt.git' deps: [stdair] - name: airsched repo: 'https://github.com/airsim/airsched.git' deps: [stdair] - name: travelccm repo: 'https://github.com/airsim/travelccm.git' deps: [stdair] - name: sevmgr repo: 'https://github.com/airsim/sevmgr.git' deps: [stdair] - name: airrac repo: 'https://github.com/airsim/airrac.git' deps: [stdair] - name: stdair repo: 'https://github.com/airsim/stdair.git' deps: {}
Good to know: if you are focusing on one specific module, you can remove everything else from the metasim file. Just be careful to check dependencies first!
For instance, if you are working on Travel-CCM only, you can keep only 'travelccm' and 'stdair'. In this case the metasim file should look like:
# MetaSim configuration file default_base_repo: 'git@github.com:airsim' default_branch: trunk cmake_args: '-DCMAKE_BUILD_TYPE:STRING=Debug -DINSTALL_DOC:BOOL=OFF \
-DENABLE_TEST:BOOL=ON -DRUN_GCOV:BOOL=OFF' publish_path: /dev/sim/metasimgit components: - name: travelccm repo: 'https://github.com/airsim/travelccm.git' deps: [stdair] - name: stdair repo: 'https://github.com/airsim/stdair.git' deps: {}
Then, you will need a minimum of development tools, including Ruby-gem based Rake, CMake, g++, Boost:
sudo yum -y install rake-rubygem cmake boost-devel gcc-c++ mysql-devel zeromq-devel soci-mysql-devel
(Git) check-out all the required components:
rake checkout
rake pull
Test the components:
rake offline=true check
Install the components:
rake offline=true install
ls -lhF workspace/install
Generate the tar-balls:
rake offline=true dist
ls -lhF /tmp/metasim
Run the local binary version to perform your first simulation:
cd workspace/build/tvlsimHave a look at the simulation logs:
./tvlsim/simulate
less simulate.logIf encounter any problem while opening a database connection, run the following batch scripts (before launching again the simulate script):
cd ../stdair
./db/admin/create_tvlsim_db.sh
./db/admin/create_airinv_db.sh
Please go to the tutorial section to learn more about the simulation tools available and how to use them.
Follow the steps below to download, build and install StdAir.
Get the StdAir library
Clone locally the full git project:
cd ~Build the StdAir project
mkdir dev
cd ~/dev/
git clone git@github.com:airsim/stdair.git stdairgit
cd stdairgit
git checkout trunk
cd ~/dev/stdairgitRun the Tests
rm -rf build && mkdir -p build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/home/[user]/dev/deliveries/stdair-99.99.99 \
-DLIB_SUFFIX=64 -DCMAKE_BUILD_TYPE:STRING=Debug -DINSTALL_DOC:BOOL=ON ..
make install
cd ~/dev/stdairgitAs a result, you should obtain a similar report:
cd build
make check
cd ~/dev/deliveries
rm -f stdair-stable
ln -s stdair-99.99.99 stdair-stable
In order to install another specific module, you need to check its dependencies in the dependencies diagram. For instance, we are going to focus on the demand generation module TraDemGen.
Clone locally the full git project:cd ~/dev
git clone git@github.com:airsim/trademgen.git trademgengit
cd trademgengit
git checkout trunk
mkdir -p build && cd build
As illustrated in the dependencies diagram, the only dependencies of TraDemgen are the StdAir and SEvMgr libraries. That is why the StdAir and SEvMgr releases, which will be used to build the Trademgen component, need to be specified:
cmake -DCMAKE_INSTALL_PREFIX=/home/[user]/dev/deliveries/trademgen-99.99.99 \Of course, you are supposed to have previously cloned, built and installed the SEvMgr library following exactly the same process as for StdAir. Do not forget that SEvMgr depends on StdAir as well!
-DWITH_STDAIR_PREFIX=/home/[user]/dev/deliveries/stdair-stable \
-DWITH_SEVMGR_PREFIX=/home/[user]/dev/deliveries/sevmgr-stable \
-DLIB_SUFFIX=64 -DCMAKE_BUILD_TYPE:STRING=Debug -DINSTALL_DOC:BOOL=ON ..
Build, install the demand generation library and perform tests:
make & make install && make check
Run the local binary version to generate your first booking requests:
./trademgen/trademgen_generateDemand -bIf encounter any problem while opening a database connection, run the following batch scripts (before launching again the generateDemand script):
./workspace/build/stdair/db/admin/create_tvlsim_db.shPlease go to the tutorial section to learn more about the simulation tools available and how to use them.
./workspace/build/stdair/db/admin/create_airinv_db.sh
tvlsimIf you chose to work within the packaged metasim component (where all simulation modules are available), the correct way to launch the binary is:
cd ~/dev/metasimgit/workspace/build/tvlsim/tvlsim./tvlsimFinally, when dealing with all the modules independently, you can choose:
cd ~/dev/tvlsimgit/tvlsim
./simulate
cd ~/dev/deliverie/tvlsim-99.99.99/bin/After running the script, you can check that a log file, named after the script, has been created in the current directory and have a look at it:
./simulate
lsless simulate.log
./simulate --help
./simulate --builtin
./simulate
./tvlsimAt this step, you should see something similar to the following screen shot:
helpTo quit the interactive scenario:
quit


-
reldens
-
demo -
go full screen
Login
Username
Password
Login error, please try again.
Firebase Login
Username
Login error, please try again.
Create Account
Email
Username
Password
Re-type your password
Registration error, please try with a different email, user or again later.
Forgot password
Email
Request error, please contact the administrator or again later.


Buffalo Plains [ar70], plain, in Imperia, peasants: 165
Last updated Turn #146
Buffalo Plains [ar70], plain, in Imperia, peasants: 165
------------------------------------------------------------------------
0: Garrison [fs7v], garrison, Imperial Empire, with ten peasants guards
0: Buffalo Plains [ar70].
18: It has begun to rain.
30: The population grows by one peasant.
Province controlled by Castle Thorbardin [v46], castle, in Thorbardin
Mountains [ao69]
Ruled by The Bard [s2a], duke
Entrance fees:
Routes leaving Buffalo Plains:
North, forest, to Imperial Forest [aq70], 8 days
Garrison [in5v], garrison, Imperial Empire, with ten peasants
Border closed.
East, mountain, to Imperial Mountains [ar71], 10 days
South, mountain, to Imperial Mountains [as70], 10 days
West, mountain, to Imperial Mountains [ar69], 10 days
It is raining.
Seen here:
Garrison [fs7v], garrison, Imperial Empire, with ten peasants
Stack of nazgul [fa4f], nazgul, number: 5


Not really in any order:
- Add multibyte handling to fields, if they get a multibyte string, try encoding it into UTF-8 B first, if this fails, throw an error.
- Cleanup the treetop parsers......... do I really need that many entrance files?
- Simplify the relationship of Headers and Fields. Doing too much of the Field work in the Header class on instantiating fields. Header should just say “Field, do it!“


Idena Paper Wallet courtesy of Angainor
Note: This is just a proof of concept, not a clean and final app. It's working, offline, safe to use, but still we'll happily accept all GUI, UX and code improvements. That's why it's open sourced!
MIT Licence: do what you want, provided you keep the credits.


| Remote Sensing Hands-On Lesson, using TGO (Python) |
Table of ContentsRemote Sensing Hands-On Lesson, using TGO (Python) Overview Note About HTML Links References Tutorials Required Readings The Permuted Index SpiceyPy API Documentation Kernels Used SpiceyPy Modules Used Time Conversion (convtm) Task Statement Learning Goals Approach Solution Solution Meta-Kernel Solution Source Code Solution Sample Output Extra Credit Task statements and questions Solutions and answers Obtaining Target States and Positions (getsta) Task Statement Learning Goals Approach Solution Solution Meta-Kernel Solution Source Code Solution Sample Output Extra Credit Task statements and questions Solutions and answers Spacecraft Orientation and Reference Frames (xform) Task Statement Learning Goals Approach Solution Solution Meta-Kernel Solution Source Code Solution Sample Output Extra Credit Task statements and questions Solutions and answers Computing Sub-s/c and Sub-solar Points on an Ellipsoid and a DSK (subpts) Task Statement Learning Goals Approach Solution Solution Meta-Kernel Solution Source Code Solution Sample Output Extra Credit Task statements and questions Solutions and answers Intersecting Vectors with an Ellipsoid and a DSK (fovint) Task Statement Learning Goals Approach Solution Solution Meta-Kernel Solution Source Code Solution Sample Output Extra Credit Remote Sensing Hands-On Lesson, using TGO (Python)
Overview
Note About HTML Links
In order for the links to be resolved, if not done already by installing the lessons package under the Toolkit's ``doc/html'' directory, create a subdirectory called ``lessons'' under the ``doc/html'' directory of the ``cspice/'' tree and copy this document to that subdirectory before loading it into a Web browser. References
Of these documents, the ``Tutorials'' contains the highest level descriptions with the least number of details while the ``Required Reading'' documents contain much more detailed specifications. The most complete specifications are provided in the ``API Documentation''. In some cases the lesson explanations also refer to the information provided in the meta-data area of the kernels used in the lesson examples. It is especially true in case of the FK and IK files, which often contain comprehensive descriptions of the frames, instrument FOVs, etc. Since both the FK and IK are text kernels, the information provided in them can be viewed using any text editor, while the meta information provided in binary kernels---SPKs and CKs---can be viewed using ``commnt'' or ``spacit'' utility programs located in ``cspice/exe'' of Toolkit installation tree. Tutorials
Name Lesson steps/functions it describes ---------------- ----------------------------------------------- Time Time Conversion SCLK and LSK Time Conversion SPK Obtaining Ephemeris Data Frames Reference Frames Using Frames Reference Frames PCK Planetary Constants Data CK Spacecraft Orientation Data DSK Detailed Target Shape (Topography) DataThese tutorials are available from the NAIF ftp server at JPL:
http://naif.jpl.nasa.gov/naif/tutorials.html Required Readings
Name Lesson steps/functions that it describes --------------- ----------------------------------------- ck.req Obtaining spacecraft orientation data dsk.req Obtaining detailed body shape data frames.req Using reference frames naif_ids.req Determining body ID codes pck.req Obtaining planetary constants data sclk.req SCLK time conversion spk.req Obtaining ephemeris data time.req Time conversion The Permuted Index
This text document provides a simple mechanism by which users can discover which SpiceyPy functions perform functions of interest, as well as the names of the source files that contain these functions.
SpiceyPy API Documentation
For example, the Python help function
>>> import spiceypy >>> help(spiceypy.str2et)describes of the str2et function's parameters, while the document
cspice/doc/html/cspice/str2et_c.htmldescribes extensively the str2et functionality. Kernels Used
1. Generic LSK: naif0012.tls 2. ExoMars-16 TGO SCLK: em16_tgo_step_20160414.tsc 3. Solar System Ephemeris SPK, subsetted to cover only the time range of interest: de430.bsp 4. Martian Satellite Ephemeris SPK, subsetted to cover only the time range of interest: mar085.bsp 5. ExoMars-16 TGO Spacecraft Trajectory SPK, subsetted to cover only the time range of interest: em16_tgo_mlt_20171205_20230115_v01.bsp 6. Generic PCK: pck00010.tpc 7. ExoMars-16 TGO FK: em16_tgo_v07.tf 8. ExoMars-16 TGO Spacecraft CK, subsetted to cover only the time range of interest: em16_tgo_sc_slt_npo_20171205_20230115_s20160414_v01.bc 9. Low-resolution Mars DSK: mars_lowres.bds 10. NOMAD IK: em16_tgo_nomad_v02.tiThese SPICE kernels are included in the lesson package available from the NAIF server at JPL:
ftp://naif.jpl.nasa.gov/pub/naif/toolkit_docs/Lessons/In addition to these kernels, the extra credit exercises require the following kernels:
11. Generic Jovian Satellite Ephemeris SPK: jup310_2018.bsp 12. EDM lander FK: em16_edm_v00.tf 13. EDM landing site SPK: em16_edm_sot_landing_site_20161020_21000101_v01.bspThese SPICE kernels are available from the NAIF server at JPL:
https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/ https://naif.jpl.nasa.gov/pub/naif/EXOMARS2016/kernels/ SpiceyPy Modules Used
CHAPTER EXERCISE FUNCTIONS NON-VOID KERNELS ------- --------- --------------- --------------- ---------- 1 convtm spiceypy.furnsh spiceypy.str2et 1,2 spiceypy.unload spiceypy.etcal spiceypy.timout spiceypy.sce2s extra (*) spiceypy.unitim 1,2 spiceypy.sct2e spiceypy.et2utc spiceypy.scs2e 2 getsta spiceypy.furnsh spiceypy.str2et 1,3-5 spiceypy.unload spiceypy.spkezr spiceypy.spkpos spiceypy.vnorm spiceypy.convrt extra (*) spiceypy.kclear spiceypy.bodn2c 1,3-6,11-13 3 xform spiceypy.furnsh spiceypy.str2et 1-8 spiceypy.unload spiceypy.spkezr spiceypy.sxform spiceypy.mxvg spiceypy.spkpos spiceypy.pxform spiceypy.mxv spiceypy.convrt spiceypy.vsep extra (*) spiceypy.kclear 1-8 4 subpts spiceypy.furnsh spiceypy.str2et 1,3-6,9 spiceypy.unload spiceypy.subpnt spiceypy.vnorm spiceypy.subslr extra (*) spiceypy.kclear spiceypy.reclat 1,3-6 spiceypy.dpr spiceypy.bodvrd spiceypy.recpgr 5 fovint spiceypy.furnsh spiceypy.str2et 1-10 spiceypy.unload spiceypy.bodn2c spiceypy.getfov spiceypy.sincpt spiceypy.reclat spiceypy.dpr spiceypy.illumf spiceypy.et2lst (*) Additional APIs and kernels used in Extra Credit tasks.Use the Python built-in help system on the various functions listed above for the API parameters' description, and refer to the headers of their corresponding CSPICE versions for detailed interface specifications. Time Conversion (convtm)Task Statement
Learning Goals
Approach
When completing the ``calendar format'' step above, consider using one of two possible methods: spiceypy.etcal or spiceypy.timout. SolutionSolution Meta-Kernel
KPL/MK This is the meta-kernel used in the solution of the ``Time Conversion'' task in the Remote Sensing Hands On Lesson. The names and contents of the kernels referenced by this meta-kernel are as follows: 1. Generic LSK: naif0012.tls 2. ExoMars-16 TGO SCLK: em16_tgo_step_20160414.tsc \begindata KERNELS_TO_LOAD = ( 'kernels/lsk/naif0012.tls', 'kernels/sclk/em16_tgo_step_20160414.tsc' ) \begintext Solution Source Code
# # Solution convtm # from __future__ import print_function from builtins import input import spiceypy def convtm(): # # Local Parameters # METAKR = 'convtm.tm' SCLKID = -143 # # Load the kernels this program requires. # Both the spacecraft clock kernel and a # leapseconds kernel should be listed in # the meta-kernel. # spiceypy.furnsh( METAKR ) # # Prompt the user for the input time string. # utctim = input( 'Input UTC Time: ' ) print( 'Converting UTC Time: {:s}'.format( utctim ) ) # # Convert utctim to ET. # et = spiceypy.str2et( utctim ) print( ' ET Seconds Past J2000: {:16.3f}'.format( et ) ) # # Now convert ET to a calendar time string. # This can be accomplished in two ways. # calet = spiceypy.etcal( et ) print( ' Calendar ET (etcal): {:s}'.format( calet ) ) # # Or use timout for finer control over the # output format. The picture below was built # by examining the header of timout. # calet = spiceypy.timout( et, 'YYYY-MON-DDTHR:MN:SC ::TDB' ) print( ' Calendar ET (timout): {:s}'.format( calet ) ) # # Convert ET to spacecraft clock time. # sclkst = spiceypy.sce2s( SCLKID, et ) print( ' Spacecraft Clock Time: {:s}'.format( sclkst ) ) spiceypy.unload( METAKR ) if __name__ == '__main__': convtm() Solution Sample Output
Input UTC Time: 2018 JUN 11 19:32:00 Converting UTC Time: 2018 JUN 11 19:32:00 ET Seconds Past J2000: 582017589.185 Calendar ET (etcal): 2018 JUN 11 19:33:09.184 Calendar ET (timout): 2018-JUN-11T19:33:09 Spacecraft Clock Time: 1/0070841719.26698 Extra Credit
These ``extra credit'' tasks are provided as task statements, and unlike the regular tasks, no approach or solution source code is provided. In the next section, you will find the numeric solutions (when applicable) and answers to the questions asked in these tasks. Task statements and questions
Solutions and answers
Julian Date TDB: 2458281.3146896
Traceback (most recent call last): File "convtm.py", line 73, in <module> convtm() File "convtm.py", line 36, in convtm et = spiceypy.str2et( utctim ) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 76, in with_errcheck checkForSpiceError(f) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 59, in checkForSpiceError raise stypes.SpiceyError(msg) spiceypy.utils.support_types.SpiceyError: ===================================================================== =========== Toolkit version: N0066 SPICE(NOLEAPSECONDS) -- The variable that points to the leapseconds (DELTET/DELTA_AT) could n ot be located in the kernel pool. It is likely that the leapseconds kernel has not been loaded via the routine FURNSH. str2et_c --> STR2ET --> TTRANS ===================================================================== ===========
Traceback (most recent call last): File "convtm.py", line 73, in <module> convtm() File "convtm.py", line 64, in convtm sclkst = spiceypy.sce2s( SCLKID, et ) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 76, in with_errcheck checkForSpiceError(f) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 59, in checkForSpiceError raise stypes.SpiceyError(msg) spiceypy.utils.support_types.SpiceyError: ===================================================================== =========== Toolkit version: N0066 SPICE(KERNELVARNOTFOUND) -- The Variable Was not Found in the Kernel Pool. SCLK_DATA_TYPE_143 not found. Did you load the SCLK kernel? sce2s_c --> SCE2S --> SCE2T --> SCTYPE --> SCLI01 ===================================================================== ===========
Earliest UTC convertible to SCLK: 2016-03-13T21:34:13.194
Spacecraft Clock Time: 1/0070841719.26698 UTC time from spacecraft clock: 2018-06-11T19:32:00.000 Obtaining Target States and Positions (getsta)Task Statement
Learning Goals
Approach
When deciding which SPK files to load, the Toolkit utility ``brief'' may be of some use. ``brief'' is located in the ``cspice/exe'' directory for C toolkits. Consult its user's guide available in ``cspice/doc/brief.ug'' for details. SolutionSolution Meta-Kernel
KPL/MK This is the meta-kernel used in the solution of the ``Obtaining Target States and Positions'' task in the Remote Sensing Hands On Lesson. The names and contents of the kernels referenced by this meta-kernel are as follows: 1. Generic LSK: naif0012.tls 2. Solar System Ephemeris SPK, subsetted to cover only the time range of interest: de430.bsp 3. Martian Satellite Ephemeris SPK, subsetted to cover only the time range of interest: mar085.bsp 4. ExoMars-16 TGO Spacecraft Trajectory SPK, subsetted to cover only the time range of interest: em16_tgo_mlt_20171205_20230115_v01.bsp \begindata KERNELS_TO_LOAD = ( 'kernels/lsk/naif0012.tls', 'kernels/spk/de430.bsp', 'kernels/spk/mar085.bsp', 'kernels/spk/em16_tgo_mlt_20171205_20230115_v01.bsp', ) \begintext Solution Source Code
# # Solution getsta.py # from __future__ import print_function from builtins import input import spiceypy def getsta(): # # Local parameters # METAKR = 'getsta.tm' # # Load the kernels that this program requires. We # will need a leapseconds kernel to convert input # UTC time strings into ET. We also will need the # necessary SPK files with coverage for the bodies # in which we are interested. # spiceypy.furnsh( METAKR ) # #Prompt the user for the input time string. # utctim = input( 'Input UTC Time: ' ) print( 'Converting UTC Time: {:s}'.format(utctim) ) # #Convert utctim to ET. # et = spiceypy.str2et( utctim ) print( ' ET seconds past J2000: {:16.3f}'.format(et) ) # # Compute the apparent state of Mars as seen from # ExoMars-16 TGO in the J2000 frame. All of the ephemeris # readers return states in units of kilometers and # kilometers per second. # [state, ltime] = spiceypy.spkezr( 'MARS', et, 'J2000', 'LT+S', 'TGO' ) print( ' Apparent state of Mars as seen ' 'from ExoMars-16 TGO in the J2000\n' ' frame (km, km/s):' ) print( ' X = {:16.3f}'.format(state[0]) ) print( ' Y = {:16.3f}'.format(state[1]) ) print( ' Z = {:16.3f}'.format(state[2]) ) print( ' VX = {:16.3f}'.format(state[3]) ) print( ' VY = {:16.3f}'.format(state[4]) ) print( ' VZ = {:16.3f}'.format(state[5]) ) # # Compute the apparent position of Earth as seen from # ExoMars-16 TGO in the J2000 frame. Note: We could have # continued using spkezr and simply ignored the # velocity components. # [pos, ltime] = spiceypy.spkpos( 'EARTH', et, 'J2000', 'LT+S', 'TGO', ) print( ' Apparent position of Earth as ' 'seen from ExoMars-16 TGO in the\n' ' J2000 frame (km):' ) print( ' X = {:16.3f}'.format(pos[0]) ) print( ' Y = {:16.3f}'.format(pos[1]) ) print( ' Z = {:16.3f}'.format(pos[2]) ) # # We need only display LTIME, as it is precisely the # light time in which we are interested. # print( ' One way light time between ExoMars-16 ' 'TGO and the apparent\n' ' position of Earth (seconds):' ' {:16.3f}'.format(ltime) ) # # Compute the apparent position of the Sun as seen from # Mars in the J2000 frame. # [pos, ltime] = spiceypy.spkpos( 'SUN', et, 'J2000', 'LT+S', 'MARS', ) print( ' Apparent position of Sun as ' 'seen from Mars in the\n' ' J2000 frame (km):' ) print( ' X = {:16.3f}'.format(pos[0]) ) print( ' Y = {:16.3f}'.format(pos[1]) ) print( ' Z = {:16.3f}'.format(pos[2]) ) # # Now we need to compute the actual distance between # the Sun and Mars. The above spkpos call gives us # the apparent distance, so we need to adjust our # aberration correction appropriately. # [pos, ltime] = spiceypy.spkpos( 'SUN', et, 'J2000', 'NONE', 'MARS' ) # # Compute the distance between the body centers in # kilometers. # dist = spiceypy.vnorm( pos ) # # Convert this value to AU using convrt. # dist = spiceypy.convrt( dist, 'KM', 'AU' ) print( ' Actual distance between Sun and ' 'Mars body centers:\n' ' (AU): {:16.3f}'.format(dist) ) spiceypy.unload( METAKR ) if __name__ == '__main__': getsta() Solution Sample Output
Input UTC Time: 2018 JUN 11 19:32:00 Converting UTC Time: 2018 JUN 11 19:32:00 ET seconds past J2000: 582017589.185 Apparent state of Mars as seen from ExoMars-16 TGO in the J2000 frame (km, km/s): X = 2911.822 Y = -2033.802 Z = -1291.701 VX = 1.310 VY = -0.056 VZ = 3.104 Apparent position of Earth as seen from ExoMars-16 TGO in the J2000 frame (km): X = -49609884.080 Y = 57070665.862 Z = 30304236.930 One way light time between ExoMars-16 TGO and the apparent position of Earth (seconds): 271.738 Apparent position of Sun as seen from Mars in the J2000 frame (km): X = -24712734.289 Y = 194560532.943 Z = 89906636.789 Actual distance between Sun and Mars body centers: (AU): 1.442 Extra Credit
These ``extra credit'' tasks are provided as task statements, and unlike the regular tasks, no approach or solution source code is provided. In the next section, you will find the numeric solutions (when applicable) and answers to the questions asked in these tasks. Task statements and questions
Solutions and answers
Traceback (most recent call last): File "getsta.py", line 128, in <module> getsta() File "getsta.py", line 47, in getsta 'LT+S', 'TGO' ) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 76, in with_errcheck checkForSpiceError(f) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 59, in checkForSpiceError raise stypes.SpiceyError(msg) spiceypy.utils.support_types.SpiceyError: ===================================================================== =========== Toolkit version: N0066 SPICE(SPKINSUFFDATA) -- Insufficient ephemeris data has been loaded to compute the state of - 143 (EXOMARS 2016 TGO) relative to 0 (SOLAR SYSTEM BARYCENTER) at the ephemeris epoch 2018 JUN 11 19:33:09.184. spkezr_c --> SPKEZR --> SPKEZ --> SPKACS --> SPKGEO ===================================================================== ===========
BRIEF -- Version 4.0.0, September 8, 2010 -- Toolkit Version N0066 Summary for: kernels/spk/de430.bsp Bodies: MERCURY BARYCENTER (1) w.r.t. SOLAR SYSTEM BARYCENTER (0) VENUS BARYCENTER (2) w.r.t. SOLAR SYSTEM BARYCENTER (0) EARTH BARYCENTER (3) w.r.t. SOLAR SYSTEM BARYCENTER (0) MARS BARYCENTER (4) w.r.t. SOLAR SYSTEM BARYCENTER (0) JUPITER BARYCENTER (5) w.r.t. SOLAR SYSTEM BARYCENTER (0) SATURN BARYCENTER (6) w.r.t. SOLAR SYSTEM BARYCENTER (0) URANUS BARYCENTER (7) w.r.t. SOLAR SYSTEM BARYCENTER (0) NEPTUNE BARYCENTER (8) w.r.t. SOLAR SYSTEM BARYCENTER (0) PLUTO BARYCENTER (9) w.r.t. SOLAR SYSTEM BARYCENTER (0) SUN (10) w.r.t. SOLAR SYSTEM BARYCENTER (0) MERCURY (199) w.r.t. MERCURY BARYCENTER (1) VENUS (299) w.r.t. VENUS BARYCENTER (2) MOON (301) w.r.t. EARTH BARYCENTER (3) EARTH (399) w.r.t. EARTH BARYCENTER (3) Start of Interval (UTC) End of Interval (UTC) ----------------------------- ------------------------- ---- 2018-JUN-09 23:30:00.000 2018-JUN-14 12:00:00.000 Summary for: kernels/spk/mar085.bsp Bodies: EARTH BARYCENTER (3) w.r.t. SOLAR SYSTEM BARYCENTER (0) MARS BARYCENTER (4) w.r.t. SOLAR SYSTEM BARYCENTER (0) SUN (10) w.r.t. SOLAR SYSTEM BARYCENTER (0) EARTH (399) w.r.t. EARTH BARYCENTER (3) PHOBOS (401) w.r.t. MARS BARYCENTER (4) DEIMOS (402) w.r.t. MARS BARYCENTER (4) MARS (499) w.r.t. MARS BARYCENTER (4) Start of Interval (UTC) End of Interval (UTC) ----------------------------- ------------------------- ---- 2018-JUN-09 23:30:00.000 2018-JUN-14 12:00:00.000 Summary for: kernels/spk/em16_tgo_mlt_20171205_20230115_v01.bsp Body: EXOMARS 2016 TGO (-143) w.r.t. MARS (499) Start of Interval (UTC) End of Interval (UTC) ----------------------------- --------------------------- -- 2018-JUN-09 23:30:00.000 2018-JUN-14 12:00:00.000
Additional kernels required for this task: 1. Generic Jovian Satellite Ephemeris SPK: jup310_2018.bsp available in the NAIF server at: https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/ satellites/a_old_versions
Actual position of Jupiter as seen from Mars in the J2000 frame (km): X = -536521483.294 Y = -384722940.461 Z = -145930841.439
Additional kernels required for this task: 1. EDM lander FK: em16_edm_v00.tf 2. EDM landing site SPK: em16_edm_sot_landing_site_20161020_21000101_v01.bsp 3. Generic PCK: pck00010.tpc available in the NAIF server at: https://naif.jpl.nasa.gov/pub/naif/EXOMARS2016/kernels/
EDM_LANDING_SITE NAIF ID: -117900 Apparent position of EDM Landing Site as seen from ExoMars-16 TGO in the J2000 frame (km): X = -131.716 Y = -2168.989 Z = 208.792
Actual (geometric) position of Sun as seen from Mars in the J2000 frame (km): X = -24730874.909 Y = 194558449.463 Z = 89906170.829 Light-time corrected position of Sun as seen from Mars in the J2000 frame (km): X = -24730866.197 Y = 194558445.149 Z = 89906168.728 Apparent position of Sun as seen from Mars in the J2000 frame (km): X = -24712733.997 Y = 194560532.846 Z = 89906636.764 Spacecraft Orientation and Reference Frames (xform)Task Statement
Learning Goals
Approach
You may find it useful to consult the permuted index, the headers of various source modules, and the following toolkit documentation:
SolutionSolution Meta-Kernel
KPL/MK This is the meta-kernel used in the solution of the ``Spacecraft Orientation and Reference Frames'' task in the Remote Sensing Hands On Lesson. The names and contents of the kernels referenced by this meta-kernel are as follows: 1. Generic LSK: naif0012.tls 2. ExoMars-16 TGO SCLK: em16_tgo_step_20160414.tsc 3. Solar System Ephemeris SPK, subsetted to cover only the time range of interest: de430.bsp 4. Martian Satellite Ephemeris SPK, subsetted to cover only the time range of interest: mar085.bsp 5. ExoMars-16 TGO Spacecraft Trajectory SPK, subsetted to cover only the time range of interest: em16_tgo_mlt_20171205_20230115_v01.bsp 6. ExoMars-16 TGO FK: em16_tgo_v07.tf 7. ExoMars-16 TGO Spacecraft CK, subsetted to cover only the time range of interest: em16_tgo_sc_slt_npo_20171205_20230115_s20160414_v01.bc 8. Generic PCK: pck00010.tpc \begindata KERNELS_TO_LOAD = ( 'kernels/lsk/naif0012.tls', 'kernels/sclk/em16_tgo_step_20160414.tsc', 'kernels/spk/de430.bsp', 'kernels/spk/mar085.bsp', 'kernels/spk/em16_tgo_mlt_20171205_20230115_v01.bsp', 'kernels/fk/em16_tgo_v07.tf', 'kernels/ck/em16_tgo_sc_slt_npo_20171205_20230115_s20160414_v01.bc', 'kernels/pck/pck00010.tpc' ) \begintext Solution Source Code
# # Solution xform.py # from __future__ import print_function from builtins import input import spiceypy def xform(): # # Local parameters # METAKR = 'xform.tm' # # Load the kernels that this program requires. We # will need: # # A leapseconds kernel # A spacecraft clock kernel for ExoMars-16 TGO # The necessary ephemerides # A planetary constants file (PCK) # A spacecraft orientation kernel for ExoMars-16 TGO (CK) # A frame kernel (TF) # spiceypy.furnsh( METAKR ) # # Prompt the user for the input time string. # utctim = input( 'Input UTC Time: ' ) print( 'Converting UTC Time: {:s}'.format(utctim) ) # #Convert utctim to ET. # et = spiceypy.str2et( utctim ) print( ' ET seconds past J2000: {:16.3f}'.format(et) ) # # Compute the apparent state of Mars as seen from # ExoMars-16 TGO in the J2000 frame. # [state, ltime] = spiceypy.spkezr( 'MARS', et, 'J2000', 'LT+S', 'TGO' ) # # Now obtain the transformation from the inertial # J2000 frame to the non-inertial body-fixed IAU_MARS # frame. Since we want the apparent position, we # need to subtract ltime from et. # sform = spiceypy.sxform( 'J2000', 'IAU_MARS', et-ltime ) # # Now rotate the apparent J2000 state into IAU_MARS # with the following matrix multiplication: # bfixst = spiceypy.mxvg ( sform, state, 6, 6 ) # # Display the results. # print( ' Apparent state of Mars as seen ' 'from ExoMars-16 TGO in the IAU_MARS\n' ' body-fixed frame (km, km/s):' ) print( ' X = {:19.6f}'.format(bfixst[0]) ) print( ' Y = {:19.6f}'.format(bfixst[1]) ) print( ' Z = {:19.6f}'.format(bfixst[2]) ) print( ' VX = {:19.6f}'.format(bfixst[3]) ) print( ' VY = {:19.6f}'.format(bfixst[4]) ) print( ' VZ = {:19.6f}'.format(bfixst[5]) ) # # It is worth pointing out, all of the above could # have been done with a single use of spkezr: # [state, ltime] = spiceypy.spkezr( 'MARS', et, 'IAU_MARS', 'LT+S', 'TGO' ) # # Display the results. # print( ' Apparent state of Mars as seen ' 'from ExoMars-16 TGO in the IAU_MARS\n' ' body-fixed frame (km, km/s) ' 'obtained using spkezr directly:' ) print( ' X = {:19.6f}'.format(state[0]) ) print( ' Y = {:19.6f}'.format(state[1]) ) print( ' Z = {:19.6f}'.format(state[2]) ) print( ' VX = {:19.6f}'.format(state[3]) ) print( ' VY = {:19.6f}'.format(state[4]) ) print( ' VZ = {:19.6f}'.format(state[5]) ) # # Note that the velocity found by using spkezr # to compute the state in the IAU_MARS frame differs # at the few mm/second level from that found previously # by calling spkezr and then sxform. Computing # velocity via a single call to spkezr as we've # done immediately above is slightly more accurate because # it accounts for the effect of the rate of change of # light time on the apparent angular velocity of the # target's body-fixed reference frame. # # Now we are to compute the angular separation between # the apparent position of Mars as seen from the orbiter # and the nominal instrument view direction. First, # compute the apparent position of Mars as seen from # ExoMars-16 TGO in the J2000 frame. # [pos, ltime] = spiceypy.spkpos( 'MARS', et, 'J2000', 'LT+S', 'TGO' ) # # Now compute the location of the nominal instrument view # direction. From reading the frame kernel we know that # the instrument view direction is nominally the -Y axis # of the TGO_SPACECRAFT frame defined there. # bsight = [ 0.0, -1.0, 0.0] # # Now compute the rotation matrix from TGO_SPACECRAFT into # J2000. # pform = spiceypy.pxform( 'TGO_SPACECRAFT', 'J2000', et ) # # And multiply the result to obtain the nominal instrument # view direction in the J2000 reference frame. # bsight = spiceypy.mxv( pform, bsight ) # # Lastly compute the angular separation. # sep = spiceypy.convrt( spiceypy.vsep(bsight, pos), 'RADIANS', 'DEGREES' ) print( ' Angular separation between the ' 'apparent position of Mars and the\n' ' ExoMars-16 TGO nominal instrument ' 'view direction (degrees):\n' ' {:16.3f}'.format(sep) ) # # Or alternatively we can work in the spacecraft # frame directly. # [pos, ltime] = spiceypy.spkpos( 'MARS', et, 'TGO_SPACECRAFT', 'LT+S', 'TGO' ) # # The nominal instrument view direction is the -Y-axis # in the TGO_SPACECRAFT frame. # bsight = [ 0.0, -1.0, 0.0 ] # # Lastly compute the angular separation. # sep = spiceypy.convrt( spiceypy.vsep(bsight, pos), 'RADIANS', 'DEGREES' ) print( ' Angular separation between the ' 'apparent position of Mars and the\n' ' ExoMars-16 TGO nominal instrument ' 'view direction computed\n' ' using vectors in the ' 'TGO_SPACECRAFT frame (degrees):\n' ' {:16.3f}'.format(sep) ) spiceypy.unload( METAKR ) if __name__ == '__main__': xform() Solution Sample Output
Input UTC Time: 2018 JUN 11 19:32:00 Converting UTC Time: 2018 JUN 11 19:32:00 ET seconds past J2000: 582017589.185 Apparent state of Mars as seen from ExoMars-16 TGO in the IAU_MARS body-fixed frame (km, km/s): X = -2843.464125 Y = 2235.459544 Z = 1095.894969 VX = 0.311443 VY = -1.151929 VZ = 3.082123 Apparent state of Mars as seen from ExoMars-16 TGO in the IAU_MARS body-fixed frame (km, km/s) obtained using spkezr directly: X = -2843.464125 Y = 2235.459544 Z = 1095.894969 VX = 0.311443 VY = -1.151929 VZ = 3.082123 Angular separation between the apparent position of Mars and the ExoMars-16 TGO nominal instrument view direction (degrees): 5.438 Angular separation between the apparent position of Mars and the ExoMars-16 TGO nominal instrument view direction computed using vectors in the TGO_SPACECRAFT frame (degrees): 5.438 Extra Credit
These ``extra credit'' tasks are provided as task statements, and unlike the regular tasks, no approach or solution source code is provided. In the next section, you will find the numeric solutions (when applicable) and answers to the questions asked in these tasks. Task statements and questions
Solutions and answers
Traceback (most recent call last): File "xform.py", line 183, in <module> xform() File "xform.py", line 130, in xform pform = spiceypy.pxform( 'TGO_SPACECRAFT', 'J2000', et ) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 76, in with_errcheck checkForSpiceError(f) File "/home/bsemenov/local/lib/python3.5/site-packages/spiceypy/spi ceypy.py", line 59, in checkForSpiceError raise stypes.SpiceyError(msg) spiceypy.utils.support_types.SpiceyError: ===================================================================== =========== Toolkit version: N0066 SPICE(NOFRAMECONNECT) -- At epoch 5.8209996918462E+08 TDB (2018 JUN 12 18:26:09.184 TDB), ther e is insufficient information available to transform from reference f rame -143000 (TGO_SPACECRAFT) to reference frame 1 (J2000). TGO_SPACE CRAFT is a CK frame; a CK file containing data for instrument or stru cture -143000 at the epoch shown above, as w pxform_c --> PXFORM --> REFCHG ===================================================================== ===========
CKBRIEF -- Version 6.1.0, June 27, 2014 -- Toolkit Version N0066 Summary for: kernels/ck/em16_tgo_sc_slt_npo_20171205_20230115_s201604 14_v01.bc Segment No.: 1 Object: -143000 Interval Begin UTC Interval End UTC AV ------------------------ ------------------------ --- 2018-JUN-10 23:59:59.999 2018-JUN-12 06:26:53.918 Y 2018-JUN-12 06:56:53.918 2018-JUN-12 18:14:33.918 Y 2018-JUN-12 18:44:33.918 2018-JUN-13 04:02:13.918 Y 2018-JUN-13 04:32:13.918 2018-JUN-13 07:58:33.918 Y 2018-JUN-13 08:28:33.918 2018-JUN-13 11:59:59.999 Y
CKBRIEF -- Version 6.1.0, June 27, 2014 -- Toolkit Version N0066 Summary for: kernels/ck/em16_tgo_sc_slt_npo_20171205_20230115_s201604 14_v01.bc Object: -143000 Interval Begin UTC Interval End UTC AV ------------------------ ------------------------ --- 2018-JUN-10 23:59:59.999 2018-JUN-13 11:59:59.999 Y
Angular separation between the apparent position of the Sun and the ExoMars-16 TGO nominal instrument view direction (degrees): 130.543 Science Deck illumination: ExoMars-16 TGO Science Deck IS NOT illuminated.
Computing Sub-s/c and Sub-solar Points on an Ellipsoid and a DSK (subpts)Task Statement
near point/ellipsoiddefinition, and once using a DSK shape model and the
nadir/dsk/unprioritizeddefinition. The program displays the results. Use the program to compute these quantities at "2018 JUN 11 19:32:00" UTC. Learning Goals
Approach
One point worth considering: how would the results change if the sub-solar and sub-observer points were computed using the
intercept/ellipsoidand
intercept/dsk/unprioritizeddefinitions? Which definition is appropriate? SolutionSolution Meta-Kernel
KPL/MK This is the meta-kernel used in the solution of the ``Computing Sub-s/c and Sub-solar Points on an Ellipsoid and a DSK'' task in the Remote Sensing Hands On Lesson. The names and contents of the kernels referenced by this meta-kernel are as follows: 1. Generic LSK: naif0012.tls 2. Solar System Ephemeris SPK, subsetted to cover only the time range of interest: de430.bsp 3. Martian Satellite Ephemeris SPK, subsetted to cover only the time range of interest: mar085.bsp 4. ExoMars-16 TGO Spacecraft Trajectory SPK, subsetted to cover only the time range of interest: em16_tgo_mlt_20171205_20230115_v01.bsp 5. Generic PCK: pck00010.tpc 6. Low-resolution Mars DSK: mars_lowres.bds \begindata KERNELS_TO_LOAD = ( 'kernels/lsk/naif0012.tls', 'kernels/spk/de430.bsp', 'kernels/spk/mar085.bsp', 'kernels/spk/em16_tgo_mlt_20171205_20230115_v01.bsp', 'kernels/pck/pck00010.tpc' 'kernels/dsk/mars_lowres.bds' ) \begintext Solution Source Code
# # Solution subpts.py # from __future__ import print_function from builtins import input # # SpiceyPy package: # import spiceypy def subpts(): # # Local parameters # METAKR = 'subpts.tm' # # Load the kernels that this program requires. We # will need: # # A leapseconds kernel # The necessary ephemerides # A planetary constants file (PCK) # A DSK file containing Mars shape data # spiceypy.furnsh( METAKR ) # #Prompt the user for the input time string. # utctim = input( 'Input UTC Time: ' ) print( ' Converting UTC Time: {:s}'.format(utctim) ) # #Convert utctim to ET. # et = spiceypy.str2et( utctim ) print( ' ET seconds past J2000: {:16.3f}'.format(et) ) for i in range(2): if i == 0: # # Use the "near point" sub-point definition # and an ellipsoidal model. # method = 'NEAR POINT/Ellipsoid' else: # # Use the "nadir" sub-point definition # and a DSK model. # method = 'NADIR/DSK/Unprioritized' print( '\n Sub-point/target shape model: {:s}\n'.format( method ) ) # # Compute the apparent sub-observer point of ExoMars-16 TGO # on Mars. # [spoint, trgepc, srfvec] = spiceypy.subpnt( method, 'MARS', et, 'IAU_MARS', 'LT+S', 'TGO' ) print( ' Apparent sub-observer point of ExoMars-16 ' 'TGO on Mars\n' ' in the IAU_MARS frame (km):' ) print( ' X = {:16.3f}'.format(spoint[0]) ) print( ' Y = {:16.3f}'.format(spoint[1]) ) print( ' Z = {:16.3f}'.format(spoint[2]) ) print( ' ALT = {:16.3f}'.format(spiceypy.vnorm(srfvec)) ) # # Compute the apparent sub-solar point on Mars # as seen from ExoMars-16 TGO. # [spoint, trgepc, srfvec] = spiceypy.subslr( method, 'MARS', et, 'IAU_MARS', 'LT+S', 'TGO' ) print( ' Apparent sub-solar point on Mars ' 'as seen from ExoMars-16 \n' ' TGO in the IAU_MARS frame (km):' ) print( ' X = {:16.3f}'.format(spoint[0]) ) print( ' Y = {:16.3f}'.format(spoint[1]) ) print( ' Z = {:16.3f}'.format(spoint[2]) ) # # End of computation block for "method" # print( '' ) spiceypy.unload( METAKR ) if __name__ == '__main__': subpts() Solution Sample Output
Input UTC Time: 2018 JUN 11 19:32:00 Converting UTC Time: 2018 JUN 11 19:32:00 ET seconds past J2000: 582017589.185 Sub-point/target shape model: NEAR POINT/Ellipsoid Apparent sub-observer point of ExoMars-16 TGO on Mars in the IAU_MARS frame (km): X = 2554.165 Y = -2008.010 Z = -983.240 ALT = 385.045 Apparent sub-solar point on Mars as seen from ExoMars-16 TGO in the IAU_MARS frame (km): X = 487.589 Y = -3348.610 Z = -286.697 Sub-point/target shape model: NADIR/DSK/Unprioritized Apparent sub-observer point of ExoMars-16 TGO on Mars in the IAU_MARS frame (km): X = 2554.223 Y = -2008.057 Z = -983.263 ALT = 384.967 Apparent sub-solar point on Mars as seen from ExoMars-16 TGO in the IAU_MARS frame (km): X = 488.096 Y = -3352.093 Z = -286.999 Extra Credit
These ``extra credit'' tasks are provided as task statements, and unlike the regular tasks, no approach or solution source code is provided. In the next section, you will find the numeric solutions (when applicable) and answers to the questions asked in these tasks. Task statements and questions
Solutions and answers
Apparent sub-solar point on Mars as seen from ExoMars-16 TGO in the IAU_MARS frame using the 'Near Point: ellipsoid' method (km): X = 487.589 Y = -3348.610 Z = -286.697 Apparent sub-solar point on Mars as seen from ExoMars-16 TGO in the IAU_MARS frame using the 'Intercept: ellipsoid' method (km): X = 487.547 Y = -3348.322 Z = -290.077
Geometric sub-spacecraft point of ExoMars-16 TGO on Phobos in the IAU_PHOBOS frame using the 'Near Point: ellipsoid' method (km): X = 12.059 Y = 4.173 Z = -0.676
Planetocentric coordinates of the ExoMars-16 TGO sub-spacecraft point on Phobos (degrees, km): LAT = -3.030 LON = 19.088 R = 12.779 Planetographic coordinates of the ExoMars-16 TGO sub-spacecraft point on Phobos (degrees, km): LAT = -6.268 LON = 340.912 ALT = -0.202
Intersecting Vectors with an Ellipsoid and a DSK (fovint)Task Statement
At each point of intersection compute the following:
Additionally compute the local solar time at the intercept of the spectrometer aperture boresight with the surface of Mars, using both ellipsoidal and DSK shape models. Use this program to compute values at the UTC epoch:
Learning Goals
Approach
SolutionSolution Meta-Kernel
KPL/MK This is the meta-kernel used in the solution of the ``Intersecting Vectors with an Ellipsoid and a DSK'' task in the Remote Sensing Hands On Lesson. The names and contents of the kernels referenced by this meta-kernel are as follows: 1. Generic LSK: naif0012.tls 2. ExoMars-16 TGO SCLK: em16_tgo_step_20160414.tsc 3. Solar System Ephemeris SPK, subsetted to cover only the time range of interest: de430.bsp 4. Martian Satellite Ephemeris SPK, subsetted to cover only the time range of interest: mar085.bsp 5. ExoMars-16 TGO Spacecraft Trajectory SPK, subsetted to cover only the time range of interest: em16_tgo_mlt_20171205_20230115_v01.bsp 6. ExoMars-16 TGO FK: em16_tgo_v07.tf 7. ExoMars-16 TGO Spacecraft CK, subsetted to cover only the time range of interest: em16_tgo_sc_slt_npo_20171205_20230115_s20160414_v01.bc 8. Generic PCK: pck00010.tpc 9. NOMAD IK: em16_tgo_nomad_v02.ti 10. Low-resolution Mars DSK: mars_lowres.bds \begindata KERNELS_TO_LOAD = ( 'kernels/lsk/naif0012.tls', 'kernels/sclk/em16_tgo_step_20160414.tsc', 'kernels/spk/de430.bsp', 'kernels/spk/mar085.bsp', 'kernels/spk/em16_tgo_mlt_20171205_20230115_v01.bsp', 'kernels/fk/em16_tgo_v07.tf', 'kernels/ck/em16_tgo_sc_slt_npo_20171205_20230115_s20160414_v01.bc', 'kernels/pck/pck00010.tpc', 'kernels/ik/em16_tgo_nomad_v02.ti' 'kernels/dsk/mars_lowres.bds' ) \begintext Solution Source Code
# # Solution fovint.py # from __future__ import print_function from builtins import input # # SpiceyPy package: # import spiceypy from spiceypy.utils.support_types import SpiceyError def fovint(): # # Local parameters # METAKR = 'fovint.tm' ROOM = 4 # # Load the kernels that this program requires. We # will need: # # A leapseconds kernel. # A SCLK kernel for ExoMars-16 TGO. # Any necessary ephemerides. # The ExoMars-16 TGO frame kernel. # An ExoMars-16 TGO C-kernel. # A PCK file with Mars constants. # The ExoMars-16 TGO NOMAD I-kernel. # A DSK file containing Mars shape data. # spiceypy.furnsh( METAKR ) # #Prompt the user for the input time string. # utctim = input( 'Input UTC Time: ' ) print( 'Converting UTC Time: {:s}'.format(utctim) ) # #Convert utctim to ET. # et = spiceypy.str2et( utctim ) print( ' ET seconds past J2000: {:16.3f}\n'.format(et) ) # # Now we need to obtain the FOV configuration of # the NOMAD LNO Nadir aperture. To do this we will # need the ID code for TGO_NOMAD_LNO_NAD. # try: lnonid = spiceypy.bodn2c( 'TGO_NOMAD_LNO_NAD' ) except SpiceyError: # # Stop the program if the code was not found. # print( 'Unable to locate the ID code for ' 'TGO_NOMAD_LNO_NAD' ) raise # # Now retrieve the field of view parameters. # [ shape, insfrm, bsight, n, bounds ] = spiceypy.getfov( lnonid, ROOM ) # # `bounds' is a numpy array. We'll convert it to a list. # # Rather than treat BSIGHT as a separate vector, # copy it into the last slot of BOUNDS. # bounds = bounds.tolist() bounds.append( bsight ) # # Set vector names to be used for output. # vecnam = [ 'Boundary Corner 1', 'Boundary Corner 2', 'Boundary Corner 3', 'Boundary Corner 4', 'TGO NOMAD LNO Nadir Boresight' ] # # Set values of "method" string that specify use of # ellipsoidal and DSK (topographic) shape models. # # In this case, we can use the same methods for calls to both # spiceypy.sincpt and spiceypy.ilumin. Note that some SPICE # routines require different "method" inputs from those # shown here. See the API documentation of each routine # for details. # method = [ 'Ellipsoid', 'DSK/Unprioritized'] # # Get ID code of Mars. We'll use this ID code later, when we # compute local solar time. # try: marsid = spiceypy.bodn2c( 'MARS' ) except: # # The ID code for MARS is built-in to the library. # However, it is good programming practice to get # in the habit of handling exceptions that may # be thrown when a quantity is not found. # print( 'Unable to locate the body ID code ' 'for Mars.' ) raise # # Now perform the same set of calculations for each # vector listed in the BOUNDS array. Use both # ellipsoidal and detailed (DSK) shape models. # for i in range(5): # # Call sincpt to determine coordinates of the # intersection of this vector with the surface # of Mars. # print( 'Vector: {:s}\n'.format( vecnam[i] ) ) for j in range(2): print ( ' Target shape model: {:s}\n'.format( method[j] ) ) try: [point, trgepc, srfvec ] = spiceypy.sincpt( method[j], 'MARS', et, 'IAU_MARS', 'LT+S', 'TGO', insfrm, bounds[i] ) # # Now, we have discovered a point of intersection. # Start by displaying the position vector in the # IAU_MARS frame of the intersection. # print( ' Position vector of surface intercept ' 'in the IAU_MARS frame (km):' ) print( ' X = {:16.3f}'.format( point[0] ) ) print( ' Y = {:16.3f}'.format( point[1] ) ) print( ' Z = {:16.3f}'.format( point[2] ) ) # # Display the planetocentric latitude and longitude # of the intercept. # [radius, lon, lat] = spiceypy.reclat( point ) print( ' Planetocentric coordinates of ' 'the intercept (degrees):' ) print( ' LAT = {:16.3f}'.format( lat * spiceypy.dpr() ) ) print( ' LON = {:16.3f}'.format( lon * spiceypy.dpr() ) ) # # Compute the illumination angles at this # point. # [ trgepc, srfvec, phase, solar, \ emissn, visibl, lit ] = \ spiceypy.illumf( method[j], 'MARS', 'SUN', et, 'IAU_MARS', 'LT+S', 'TGO', point ) print( ' Phase angle (degrees): ' '{:16.3f}'.format( phase*spiceypy.dpr() ) ) print( ' Solar incidence angle (degrees): ' '{:16.3f}'.format( solar*spiceypy.dpr() ) ) print( ' Emission angle (degrees): ' '{:16.3f}'.format( emissn*spiceypy.dpr()) ) print( ' Observer visible: {:s}'.format( str(visibl) ) ) print( ' Sun visible: {:s}'.format( str(lit) ) ) if i == 4: # # Compute local solar time corresponding # to the light time corrected TDB epoch # at the boresight intercept. # [hr, mn, sc, time, ampm] = spiceypy.et2lst( trgepc, marsid, lon, 'PLANETOCENTRIC' ) print( '\n Local Solar Time at boresight ' 'intercept (24 Hour Clock):\n' ' {:s}'.format( time ) ) # # End of LST computation block. # except SpiceyError as exc: # # Display a message if an exception was thrown. # For simplicity, we treat this as an indication # that the point of intersection was not found, # although it could be due to other errors. # Otherwise, continue with the calculations. # print( 'Exception message is: {:s}'.format( exc.value )) # # End of SpiceyError try-catch block. # print( '' ) # # End of target shape model loop. # # # End of vector loop. # spiceypy.unload( METAKR ) if __name__ == '__main__': fovint() Solution Sample Output
Input UTC Time: 2018 JUN 11 19:32:00 Converting UTC Time: 2018 JUN 11 19:32:00 ET seconds past J2000: 582017589.185 Vector: Boundary Corner 1 Target shape model: Ellipsoid Position vector of surface intercept in the IAU_MARS frame (km): X = 2535.004 Y = -2028.528 Z = -990.594 Planetocentric coordinates of the intercept (degrees): LAT = -16.967 LON = -38.667 Phase angle (degrees): 48.207 Solar incidence angle (degrees): 43.872 Emission angle (degrees): 4.798 Observer visible: true Sun visible: true Target shape model: DSK/Unprioritized Position vector of surface intercept in the IAU_MARS frame (km): X = 2535.278 Y = -2028.712 Z = -990.688 Planetocentric coordinates of the intercept (degrees): LAT = -16.967 LON = -38.667 Phase angle (degrees): 48.207 Solar incidence angle (degrees): 44.387 Emission angle (degrees): 4.326 Observer visible: true Sun visible: true Vector: Boundary Corner 2 Target shape model: Ellipsoid Position vector of surface intercept in the IAU_MARS frame (km): X = 2525.056 Y = -2042.075 Z = -988.196 Planetocentric coordinates of the intercept (degrees): LAT = -16.925 LON = -38.963 Phase angle (degrees): 50.707 Solar incidence angle (degrees): 43.586 Emission angle (degrees): 7.432 Observer visible: true Sun visible: true Target shape model: DSK/Unprioritized Position vector of surface intercept in the IAU_MARS frame (km): X = 2525.359 Y = -2042.259 Z = -988.299 Planetocentric coordinates of the intercept (degrees): LAT = -16.925 LON = -38.962 Phase angle (degrees): 50.707 Solar incidence angle (degrees): 42.457 Emission angle (degrees): 8.610 Observer visible: true Sun visible: true Vector: Boundary Corner 3 Target shape model: Ellipsoid Position vector of surface intercept in the IAU_MARS frame (km): X = 2525.201 Y = -2042.104 Z = -987.770 Planetocentric coordinates of the intercept (degrees): LAT = -16.917 LON = -38.962 Phase angle (degrees): 50.708 Solar incidence angle (degrees): 43.585 Emission angle (degrees): 7.413 Observer visible: true Sun visible: true Target shape model: DSK/Unprioritized Position vector of surface intercept in the IAU_MARS frame (km): X = 2525.506 Y = -2042.289 Z = -987.874 Planetocentric coordinates of the intercept (degrees): LAT = -16.917 LON = -38.961 Phase angle (degrees): 50.708 Solar incidence angle (degrees): 42.457 Emission angle (degrees): 8.593 Observer visible: true Sun visible: true Vector: Boundary Corner 4 Target shape model: Ellipsoid Position vector of surface intercept in the IAU_MARS frame (km): X = 2535.149 Y = -2028.558 Z = -990.170 Planetocentric coordinates of the intercept (degrees): LAT = -16.960 LON = -38.666 Phase angle (degrees): 48.208 Solar incidence angle (degrees): 43.871 Emission angle (degrees): 4.769 Observer visible: true Sun visible: true Target shape model: DSK/Unprioritized Position vector of surface intercept in the IAU_MARS frame (km): X = 2535.423 Y = -2028.741 Z = -990.263 Planetocentric coordinates of the intercept (degrees): LAT = -16.960 LON = -38.665 Phase angle (degrees): 48.208 Solar incidence angle (degrees): 44.387 Emission angle (degrees): 4.297 Observer visible: true Sun visible: true Vector: TGO NOMAD LNO Nadir Boresight Target shape model: Ellipsoid Position vector of surface intercept in the IAU_MARS frame (km): X = 2530.122 Y = -2035.307 Z = -989.188 Planetocentric coordinates of the intercept (degrees): LAT = -16.942 LON = -38.814 Phase angle (degrees): 49.457 Solar incidence angle (degrees): 43.729 Emission angle (degrees): 6.086 Observer visible: true Sun visible: true Local Solar Time at boresight intercept (24 Hour Clock): 14:51:36 Target shape model: DSK/Unprioritized Position vector of surface intercept in the IAU_MARS frame (km): X = 2530.471 Y = -2035.529 Z = -989.307 Planetocentric coordinates of the intercept (degrees): LAT = -16.942 LON = -38.813 Phase angle (degrees): 49.457 Solar incidence angle (degrees): 44.387 Emission angle (degrees): 5.462 Observer visible: true Sun visible: true Local Solar Time at boresight intercept (24 Hour Clock): 14:51:36 Extra Credit
|


With a simple but reduced design and a focus on the web content first, start your exploration with us!
Cosmos is focused on the website and not the browser. Focusing on maximizing the web content size without interupting how the browser works.
By having the browser tabs in a non-standard dropdown, this allows us to protect you from both peering eyes of the world around you and even further clean and reduce the size of the interface.
The technology of our world is meant to evolve and we are always looking for new features to add to Cosmos. Reach out to us to push an idea or help push ideas that could change cosmos forever!


Survey Monkey Web Data Connector
You are signed in!
You are not signed in, please click below to authenticate
Survey Monkey Sign In
Please Select a Survey to Import
get my data!