Modals
The bootstrap-modbox library provides several convenience class methods to easily create alert, confirm, and prompt type modals. These mimic the browser dialogs that can be called by their respective JavaScript functions, except for the fact that, like native Bootstrap modals, they're asyncronous - meaning they do not block the browser thread.
In addition, custom and more advanced modals may be created by calling the constructor directly (new modbox(options)
).
Information
All of the class modal methods return a Promise, whereas calling the constuctor does not. For.confirm()
and .prompt()
, the Promise is resolved when clicking the okButton
, and rejected when the modal is closed in any other way (closeButton
, 'X', ESC key, clicking the backdrop, etc). For .alert()
and its variants, which only have the single Close button, the Promise is always resolved.
- modbox.alert(
object options
) -
Creates an alert type modal. In addition, there are several methods that create variants of this modal which are all functionally identical, but serve as shortcuts to different header styles. Alert modals using other styles not defined as method variants may be created by passing the
style
configuration option.Variant Description modbox.info(object options)
Creates an alert type modal, with an info
Bootstrap styled header background.modbox.success(object options)
Creates an alert type modal, with a success
Bootstrap styled header background.modbox.danger(object options)
Creates an alert type modal, with a danger
Bootstrap styled header background.modbox.error(object options)
Alternate method name for the .danger()
modal. - modbox.confirm(
object options
) - Creates a confirm type modal.
- modbox.prompt(
object options
) -
Creates a prompt type modal. The value of the input field is passed to the Promise
resolve()
function.Important
The input value returned when the Promise is resolved is not sanitized in any way. If the intent is to store or process this data, it is your responsibility to make sure it is safe. - new modbox(
object options
) - Lacks the extra scaffolding present in the class methods above, which allows for the creation of custom and more advanced modals. Returns a modbox object.
Options
A configuration object to be passed in to any modbox modal. If a string is passed in place of the options object when creating a modbox, it will be used as the body
.
- backdrop Bootstrap native
-
Type:
boolean
|string
Default:
true
Includes a modal-backdrop element. Alternatively, specify
'static'
for a backdrop which doesn't close the modal on click. - body
-
Type:
string
This option is required
A string consisting of plain text or HTML markup which will be used as the main body of the modal.
- buttons Only available to custom modals
-
Type:
array
Default:
[]
Each item in the array is an object defining the button configuration. If a custom or more advance button is necessary, a string containing the HTML markup may be passed instead of the configuration object.
Important
This option is only available to custom modals created by calling the constructor directly (new modbox(options)
). The class modals.confirm()
and.prompt()
instead have the special optionsokButton
andcloseButton
, whereas.alert()
and its variants only havecloseButton
. Both of these special button objects accept the same configuration options below.Option Type Default Description callback function
null
Function to be called when the button is clicked. It is passed two arguments: the event object, and the modbox instance object. Also, the function context ( this
) is set to the button element.class string
''
Additional class list that will be added to the button's class
attribute.close boolean
true
Whether the modal will automatically close when the button is clicked. disabled boolean
false
Adds the disabled
attribute.icon string
null
Class list (eg. 'fas fa-times'
) used to add an icon to the button. The markup injected is for use by icon font libraries matching the pattern
(Font Awesome, Material Design, etc). Otherwise, if you are using ligatures or non-font based icon sets (img, svg, etc), the markup can be manually added to thelabel
option:'close Close'
id string
'modbox-btn-[random #]'
Sets the id
attribute.label string
'Close'
Sets the displayed text (custom HTML markup supported). outline boolean
false
Whether to use the outline button style. size string
null
Sets an alternate button size. Possible values: sm, lg
style string
'secondary'
Sets the color based on the predefined Bootstrap utility classes. Possible values: primary, secondary, success, danger, warning, info, light, dark, link
title string
null
Sets the title
attribute. - center
-
Type:
boolean
Default:
false
Vertically centers the modal within the viewport.
- closeButton Only available to class modals
-
Type:
object
Default:
[default button]
Configuration for the "Close" button. This is a special option only available to the class modals
.alert()
(and variants),.confirm()
, and.prompt()
. Accepts the same configuration options as a standardbuttons
object. Also rejects the returned Promise. - destroyOnClose Only available to custom modals
-
Type:
boolean
Default:
false
Automaticlly calls the
destroy()
method when the modal is closed. This option is ignored for the class modals.alert()
,.confirm()
, and.prompt()
, as they are always destroyed on close. - defaultButton Only available to custom modals
-
Type:
boolean
Default:
true
Automatically adds a default button to the footer which closes the modal. This option is ignored if custom buttons are defined with the
buttons
option. If set tofalse
and nobuttons
are specified, the modal footer is hidden. - events
-
Type:
object
Default:
{}
An object containing event keys and a corresponding callback function. See the Events section for more details.
- fade
-
Type:
boolean
Default:
true
Animates the modal when shown and hidden.
- focus Bootstrap native
-
Type:
boolean
Default:
true
Puts the focus on the modal when initialized.
- icon
-
Type:
string
Default:
null
Class list (eg.
'fas fa-exclamation-triangle'
) used to add an icon to the modal header. The markup injected is for use by icon font libraries matching the pattern
(Font Awesome, Material Design, etc). Otherwise, if you are using ligatures or non-font based icon sets (img, svg, etc), the markup can be manually added to thetitle
option:'warning Error'
- id
-
Type:
string
Default:
'modbox-[random #]'
Sets the
id
attribute of the top-level modal element. - input Only available to .prompt() modal
-
Type:
object
|string
Default:
object
Defines the
input
field element that will be added to the modal body. This is a special option only available to the class modal.prompt()
.If a custom or more advance field is necessary, a string containing the HTML markup may be passed instead of the configuration object. However, please note that if a custom field is used, its value will not be passed to the Promise
resolve()
function, and any necessary validation and/or logic must be handled manually (modal events, button callbacks, etc).Option Type Default Description autocomplete string
'off'
Sets the autocomplete
attribute.class string
''
Additional class list that will be added to the class
attribute.id string
'modbox-input-[random #]'
Sets the id
attribute.maxlength number
null
Sets the maxlength
attribute.minlength number
null
Sets the minlength
attribute. If set, the validity of the input field will be checked when clicking theokButton
.pattern string, regexp
null
Sets the pattern
attribute. If set, the validity of the input field will be checked when clicking theokButton
. If passing a string, backslashes much be escaped - eg./\d+/
or'\\d+'
.placeholder string
null
Sets the placeholder
attribute.required boolean
false
Adds the required
attribute. Iftrue
, the validity of the input field will be checked when clicking theokButton
.title string
null
Sets the title
attribute.type string
'text'
Sets the type
attribute.value string
''
Sets the initial value of the input field. - justifyButtons
-
Type:
string
Default:
null
Adds Bootstrap flex utility classes to the modal footer to alter the alignment of the buttons. Possible values:
start, end, center, between, around, evenly
- keyboard Bootstrap native
-
Type:
boolean
Default:
true
Closes the modal when ESC key is pressed.
- okButton Only available to class modals
-
Type:
object
Default:
[default button]
Configuration for the "OK" button. This is a special option only available to the class modals
.confirm()
and.prompt()
. Accepts the same configuration options as a standardbuttons
object. Also resolves the returned Promise, and in the case of.prompt()
, the value of the input field is passed to theresolve()
function. -
Type:
element
Default:
undefined
Sets the
relatedTarget
property on the event object passed toshow
andshown
event callback functions. Can be overridden by passing in an element when calling the.show()
method. - scrollable
-
Type:
boolean
Default:
true
Allows long content of the modal body to scroll as opposed to scrolling the viewport.
- show Only available to custom modals
-
Type:
boolean
Default:
false
Whether the modal will be shown immediately upon creation. This option is ignored for the class modals
.alert()
,.confirm()
, and.prompt()
, as they are always shown immediately. - size
-
Type:
string
Default:
null
Sets an alternate size for the modal. Possible values:
sm, lg, xl, fullscreen
- style
-
Type:
string
Default:
'white'
Sets the header background color based on the predefined Bootstrap utility classes. Possible values:
primary, secondary, success, danger, warning, info, light, dark, body, white
- swapButtonOrder
-
Type:
boolean
Default:
false
Reverses the order of the buttons in the modal footer. This setting also affects where new buttons are appended when using the
.addButton()
method. - title
-
Type:
string
Default:
'Information'
Sets the text displayed in the modal header (custom HTML markup supported). If set to
null
or an empty string, the header will be hidden. - titleStyle
-
Type:
string
Default:
null
Sets the title text color based on the predefined Bootstrap utility classes. If
null
, this will be automatically set todark
orwhite
, depending on the value of thestyle
option. Possible values:primary, secondary, success, danger, warning, info, light, dark, body, white, muted
Properties
Unless otherwise specified, all properties are read-only.
Instance Properties
The following properties can be referenced on any instance of a modbox object.
- buttons
-
Type:
array
An array of button elements in the footer of the modal.
- modal
-
Type:
object
The native bootstrap modal object.
- modalEl
-
Type:
element
The top-level
.modal
DOM element. - options
-
Type:
object
The options configuration object that was used to create the modbox modal.
Class/Static Properties
The following properties are available to the modbox class.
- container
-
Type:
element
The
#modbox-container
DOM element that holds all modboxes. - defaultOptions
-
Type:
object
Getter or setter. Returns the current default modal configuration options, or allows you to overwrite them for future modals. Button options set by
buttons
,okButton
, andcloseButton
have precedence overdefaultButtonOptions
console.log(modbox.defaultOptions); // or modbox.defaultOptions = { style: 'info', center: true, closeButton: { label: 'Go Away!' } };
- defaultButtonOptions
-
Type:
object
Getter or setter. Returns the current default button configuration options, or allows you to overwrite them for future buttons.
console.log(modbox.defaultButtonOptions); // or modbox.defaultButtonOptions = { outline: true, callback: () => console.log('You clicked a button'); };
- version
-
Type:
string
The version of the modbox library being used.
Methods
Instance Methods
The following methods can be called on any instance of a modbox object.
- addButton(
object options
,boolean appendStart
) -
Returns:
element button
Appends a button to the footer of the modal. If the
appendStart
argument istrue
(defaultfalse
) or theswapButtonOrder
option wastrue
when the modal was created, new buttons will be added as the first child of the footer (to the left), otherwise they will be added as the last child (to the right). However, theappendStart
argument will always override theswapButtonOrder
config option. See thebuttons
options for more details.const newButton = myModbox.addButton({ label: 'New Button' });
- addEvent(
string type
,function callback
) -
Add an event to the modal. See the Events section for more details.
myModbox.addEvent('hide', () => console.log('hiding modal'));
- destroy()
-
Completely deletes the modal. Calls
.dispose()
to clean up the stored data, and removes applicable elements from the DOM. - dispose() Bootstrap native
-
Destroys an element's modal. (Removes stored data on the DOM element)
- handleUpdate() Bootstrap native
-
Manually readjust the modal's position if the height of a modal changes while it is open (i.e. in case a scrollbar appears).
- hide() Bootstrap native
-
Manually hides a modal. Returns to the caller before the modal has actually been hidden (i.e. before the
hidden.bs.modal
event occurs). - show(
element relatedTarget
) Bootstrap native -
Manually opens a modal. Returns to the caller before the modal has actually been shown (i.e. before the
shown.bs.modal
event occurs). Also, you can pass a DOM element as an argument that can be received in the modal events (as therelatedTarget
property). If no element is passed, therelatedTarget
modal configuration option will be used instead (if set). - toggle() Bootstrap native
-
Manually toggles a modal. Returns to the caller before the modal has actually been shown or hidden (i.e. before the
shown.bs.modal
orhidden.bs.modal
event occurs).
Class/Static Methods
The following methods are available to the modbox class.
- alert(
object options
) -
Returns:
promise
Creates an alert type modal.
- confirm(
object options
) -
Returns:
promise
Creates a confirm type modal.
- danger(
object options
) -
Returns:
promise
Creates an alert type modal, with a
danger
Bootstrap styled header background. - error(
object options
) -
Returns:
promise
Alternate method name for the
.danger()
modal. - getInstance(
element modal
) Bootstrap native -
Returns:
object modal
Get the modal instance associated with a DOM element.
- getOrCreateInstance(
element modal
) Bootstrap native -
Returns:
object modal
Get the modal instance associated with a DOM element, or create a new one in case it wasn't initialized.
- info(
object options
) -
Returns:
promise
Creates an alert type modal, with an
info
Bootstrap styled header background. - prompt(
object options
) -
Returns:
promise
Creates a prompt type modal.
- success(
object options
) -
Returns:
promise
Creates an alert type modal, with a
success
Bootstrap styled header background.
Events
All native Bootstrap events are supported through the events
configuration option, or by calling the addEvent()
instance method. The callback functions are passed two arguments: the event object, and the modbox instance object. Also, the function context (this
) is set to the top-level .modal
DOM element.
new modbox({
events: {
shown: () => console.log('modal shown'),
hidden: () => console.log('modal hidden')
}
});
| Type | Bootstrap Event | Description |
|---|---|---|
show |
show.bs.modal |
This event fires immediately when the show() instance method is called. If caused by a click, the clicked element is available as the relatedTarget property of the event. |
shown |
shown.bs.modal |
This event is fired when the modal has been made visible to the user (will wait for CSS transitions to complete). If caused by a click, the clicked element is available as the relatedTarget property of the event. |
hide |
hide.bs.modal |
This event is fired immediately when the hide() instance method has been called. |
hidden |
hidden.bs.modal |
This event is fired when the modal has finished being hidden from the user (will wait for CSS transitions to complete). |
hidePrevented |
hidePrevented.bs.modal |
This event is fired when the modal is shown, its backdrop is static and a click outside the modal or the ESC key press is performed with the keyboard option set to false . |


Sorry! Due to restrictions in Google's apis, only the user signed into this Chrome profile can use the extension.
To work around this, you'll need to create a new Chrome profile and install the extension to it.


Global Options dialog box
There are many settings that can be changed in this dialog box. For example,
- To change the text font, go to Text Area.
- To change the tab width and other editor settings, go to Editor.
- To dock plugin windows into the view, go to Docking.
- To change other plugin settings, go to Plugin Options.
- If you're behind an HTTP proxy and would like to use the plugin
manager to install plugins, go to HTTP Proxy.


SN college football rankings Week 14: Oregon loss shakes up Playoff race
by Zac Al-KhateebOnly one week remains in college football's regular season, yet we found out once again on Saturday that every game counts in the lead-up to the final set of College Football Playoff rankings.
We saw that with Oregon's 31-28 loss to a .500 Arizona State team, and nearly saw it again when Oklahoma staved off an upset from TCU thanks to a controversial spot by officials late in the game.
MORE: Week 14 College Football Playoff picture
The Playoff picture became further clarified with Ohio State's defeat of Penn State, as well. The Buckeyes will face Saturday's winner of the Paul Bunyan's Axe between Minnesota and Wisconsin.
With that, here is Sporting News' latest set of college football rankings ahead of the Week 14 slate of games.
Sporting News Week 14 college football rankings
| Rank | Team | Change |
| 1 | LSU (11-0) | — |
| 2 | Ohio State (11-0) | — |
| 3 | Clemson (11-0) | — |
| 4 | Georgia (10-1) | — |
| 5 | Alabama (10-1) | +1 |
| 6 | Utah (10-1) | +2 |
| 7 | Oklahoma (10-1) | — |
| 8 | Minnesota (10-1) | +1 |
| 9 | Baylor (10-1) | +2 |
| 10 | Michigan (9-2) | +2 |
| 11 | Oregon (9-2) | -6 |
| 12 | Penn State (9-2) | -2 |
| 13 | Notre Dame (9-2) | +1 |
| 14 | Florida (9-2) | -1 |
| 15 | Memphis (10-1) | — |
| 16 | Boise State (10-1) | — |
| 17 | Wisconsin (9-2) | — |
| 18 | Auburn (8-3) | — |
| 19 | Cincinnati (10-1) | — |
| 20 | Navy (8-2) | NR |
| 21 | Iowa (8-3) | — |
| 22 | App State (10-1) | — |
| 23 | Louisiana (9-2) | +1 |
| 24 | SMU (9-2) | -4 |
| 25 | Virginia Tech (8-3) | NR |
Moved in: Navy, Virginia Tech
Dropped out: San Diego State, Texas A&M


WITNESS LIST
Finance
May 16, 2011 9:00 AM
ON:
Norris, Robert LBB Staff (LBB)
FOR:
Kroll, John Economist (City of Humble), Austin, TX
Registering, but not testifying:
For:
Wynn, Monty (Texas Municipal League), Austin
Registering, but not testifying:
For:
Gonzalez, Daniel Consultant (Texas Association of Realtors), Austin, TX
FOR:
Alexander, Wayne Chairman - Port Authority of San Antonio (Port Authority of San
Antonio), San Antonio, TX
Perez, Richard CEO (The Greater San Antonio Chamber of Commerce), San Antonio, TX
Registering, but not testifying:
For:
Bellsnyder, Luke Lobby/Advocacy (Texas Assn. of Manufacturers)
Christian, George attorney (Texas Taxpayers and Research Association), Austin, TX
Contreras, Carlos (City of San Antonio), San Antonio, TX
Dodson, Jeffrey A. Director - Gov't Relations (The Boeing Company)
Salinas, Nelson Govt. Affairs Manager (Texas Assoc. of Business), Austin, TX
Shelley, Dan Consultant (Lockheed Martin Aerospace), Austin, TX
Vieweg, Scott Director of Commercial Programs (The Boeing Company)
FOR:
Kroll, John Economist (City of Humble), Austin, TX
Registering, but not testifying:
For:
Patterson, T.J. (City of Fort Worth)
FOR:
Brusniak, John Attorney (Brusniak/Blackwell), Dallas, TX
Popp, Jim Attorney (Popp Gray & Hutcheson)
Registering, but not testifying:
For:
Allen, George B. Executive Vice President (Texas Apartment Association), Austin, TX
Christian, George attorney (Texas Taxpayers and Research Association), Austin, TX
1
WITNESS LIST
Finance
May 16, 2011 9:00 AM
Gonzalez, Daniel Consultant (Texas Association of Realtors), Austin, TX
Norman, Scott Executive Director (Texas Association of Builders), Austin, TX
Parsley, Cathleen Chief Administrative Law Judge (State Office of Administrative
Hearings), Austin, TX
Ramirez, Melissa Attorney, Popp Gray & Hutcheson (American Property Tax Counsel),
Austin, TX
FOR:
Alexander, Wayne Chairman - Port Authority of San Antonio (Port Authority of San
Antonio), San Antonio, TX
Perez, Richard CEO (The Greater San Antonio Chamber of Commerce), San Antonio, TX
Vieweg, Scott Director of Commercial Programs (Boeing)
ON:
Dudley, Scott LBB Staff (LBB)
Registering, but not testifying:
For:
Bellsnyder, Luke Lobby/Advocacy (Texas Assn. of Manufacturers)
Christian, George attorney (Texas Taxpayers and Research Association), Austin, TX
Contreras, Carlos (City of San Antonio), San Antonio, TX
Dodson, Jeffrey A. Director - Gov't Relations (The Boeing Company)
Salinas, Nelson Govt. Affairs Manager (The Texas Assoc. of Business), Austin, TX
Shelley, Dan consultant (Lockheed Martin Aerospace), Austin, TX
2


| Bet Types | Terms | Winning Odds | Winning Forms Sample |
|---|---|---|---|
| Pick one boat of first place winner. | 1／6 | ||
| Pick one boat to finish within the first two places. | 1／3 | ||
| Pick two boats to finish first and second in exact order. | 1／30 | ||
| Pick two boats to finish within the first two places. | 1／15 | ||
| Pick three boats to finish first, second, and third in exact order. | 1／120 | ||
| Pick three boats to finish within the first three places in any order. | 1／20 | ||
| Pick two boats to finish either first, second, or third in any order. | 3／15 |


So you’ve built a website, and it looks fine on your computer. That’s great! But how do you know it’ll look the same on other people’s computers? And what about phones? We haven’t even talked about how your website might look on mobile devices even though people spend more time online on mobile than any other platform. In short, the problem is that you don’t know how your website will respond when pulled up on screens of different sizes. Here, we’ll cover some different resources and general ideas on how to tackle that issue.
Different websites handle responsiveness in different ways, some better than others. You’ve probably seen websites that direct you to a completely different site if you’re visiting on a phone, or even some that outright prevent you from accessing a website if they see you’re on a mobile device. While the first option is bad because it means you have to write two separate websites (which means twice the editing any time you want to change something!), it’s easy to understand why the second option is worse: people who want to access your site on mobile won’t get anything at all.
The better option is to create a responsive website – a single website that changes its layout and content automatically depending on the screen size and resolution – so everything stays centralized and neat.
Responsive design is an issue that has been pondered by many a mind, and as a result there is no shortage of possible solutions readily available. Many are HTML, CSS and/or Javascript frameworks that revolve around a common grid system or allow you to easily define your own.
If you’re planning on getting deeper into the world of code (trust me, it gets a lot deeper), you’re going to be seeing the words “framework” and “library” a lot, sometimes used interchangeably. It can be easy to get confused on what exactly these are, so here’s a quick (and by no means final) explanation:
A library as a concept is a bit older than a framework, and it’s basically just code that someone else has written that makes some part of your job easier. That code can be anything, from CSS stylings to HTML layouts to Javascript functions.  It’s yours. You typically won’t have to modify code found in a library.
A framework is similar to a library in that it provides pre-written code that fulfills some functionality, but differs in that it’s typically more of an outline that you have to flesh out. A framework can be a library, but is distinguished in how it’s used: frameworks still require you to do the heavy lifting (you still have to decide how to use it, which features to implement, etc), while a library helps you once you’ve made those decisions.
To be honest, there is no hard and fast definition for libraries or frameworks, or even for what the difference is between the two. In general however, libraries are typically smaller and simpler, while frameworks are larger but more robust.
If you’ve ever designed for a magazine or newspaper, you’re probably familiar with grid systems. Grids allow you to easily organize content and layout using columns and make it easy to plan out and change designs. A layout can be split into any number of total columns, but the most common number is 12, a nice multiple of both three and four.
Typically, the columns are placed on the inside of the page or screen so that there is space around the columns on all sides. This spacing is referred to as the margin, and is just there to make sure your content doesn’t seem cramped. There’s spacing in between columns as well: those spaces are called the gutters and are also there to promote legibility.
Content can be made to span across any number of columns: a big splash image might take up all 12 columns across (or may even ignore margins and take up the entire width of the screen), while you might only want your body copy to span six columns.
Perhaps the most popular responsive design framework is Bootstrap, a mobile-first approach to building websites that uses the 12-column grid system we just mentioned and comes preloaded with its own HTML, CSS, and Javascript. We’ll be using Bootstrap in this lesson to introduce you to responsive web development.
There are a few ways of hooking up Bootstrap to your website, but the easiest way is to simply link it like any other stylesheet through their CDN:
One thing to watch out for in front-end web development is the ordering of your stylesheets. You’ll most likely want to link Bootstrap’s optional theme along with the core CSS because it’s relatively nice-looking and just means less work for you. However, if you want to make your own changes to elements after installing the theme, you might run into some trouble for two reasons.
For one, CSS is very particular about priority level for styles, and rightfully so. In CSS, because there are so many different ways of selecting elements, it’s possible to style the same element via multiple selectors, and so a strict priority system is necessary to ensure that elements can be styled in a predictable and manageable way. For selectors, the order goes element, class, ID from lowest to highest priority (element names get a priority of one, classes ten, and IDs 100), and more specific selectors get priority over less specific ones.
For example, if you’re modifying an element such as:
with the following CSS in an external stylesheet:
the paragraph text will always appear green. Taking away the #example-id rule will turn the paragraph blue, and finally removing the .example-class rule will turn the paragraph red.
Secondly, because CSS is cascading, it also styles elements based on the last rule read about that element. This means that not only do later rules on the same stylesheet override earlier ones (as long as it has an equal or higher priority level), but also rules that are introduced in later stylesheets override those found in earlier stylesheets.
What does this mean for you? If you’re trying to style something that’s been pre-styled with Bootstrap’s theme and it’s not appearing the way you expect it to, make sure that your custom stylesheet is placed lower in the HTML head section than the Bootstrap theme. Also, try to be as specific as possible, using IDs where necessary.
Keep in mind that you’ll also need jQuery, a Javascript library, for all of Bootstrap’s Javascript plugins. You can add that here, and make sure to hook up the jQuery before hooking up the Bootstrap Javascript plugin:
Another thing to keep in mind that may not be obvious at first is that these links all point to servers. That means that your website won’t work without an internet connection. This won’t be a problem if your site itself is hosted on a server, as retrieving the site in the first place requires an internet connection. However, this does mean that your website won’t open correctly on your computer while you’re editing the files if you’re not connected to the internet.
To utilize the Bootstrap components, you’ll be adding classes to your elements to describe how they should function. To start off, you’ll need a Bootstrap container, so put that in your body:
Now within that container we can start to build out the innards of the website. Inside the container div, make another div with a row class.
As you might expect, this div will now function as a row into which we can start putting our other components. The row serves as a container for the 12 columns that we’re going to be making use of soon. But first, let’s get a visualization of how the grid system actually works.
Each column should be wrapped in its own div and will belong to a class that describes how wide it will appear and at what sizes. Let’s see how this works. Inside your row div, insert a column div:
Inside your custom CSS file, go ahead and add a rule to make the background-color of all one-width columns red. We’ll also give the column a height of 50px.
Save, then open your HTML in your browser, and you see a small red rectangle at the top of your screen. The width of that rectangle represents how much space one column gets. Of course, there’s space between columns (although this comes in the form of padding, which is on the inside of the div, rather than margin, which is on the outside), so a two-width column of text will be more than twice as wide as its one-width counterpart, but not by much. In your HTML document, copy and paste the col-md-1 div 11 more times in the same row and refresh your screen. Try typing some placeholder text inside the div. You can even try playing around with the numbers: see what happens if you change one of the columns to col-md-3 or col-md-4 (be sure to change the colors so you can tell which width is which). It may seem pretty obvious at this point, but the number at the end of the class just determines how many columns that div will span, up to 12. What may be a little less obvious is what the “md” stands for.
Bootstrap has four main classifications for devices: extra-small (phones with a screen width of less than 768px), small (tablets with a width of 768px or more), medium (desktops with a width of 992px or more), and large (big desktops with a width of 1200px or more). Because you might want the layout of your website to appear differently on different screens, you can change how wide a div will be for a given screen size by merely appending column classes. The following div:
will span six columns on an extra-small screen and three columns on a medium-sized screen. Keep in mind that these classification systems are based on device width, and orientation may still play a role as to how your website looks and handles.
Let’s get a fresh start: go ahead and delete everything we did in the previous steps except for the container and row divs in your HTML file. We’ll be making a super hip and modern portfolio site, so we should start off with a big splash image. You can use any relatively large landscape-oriented image you want (if you can’t find one you’d want to use right now, check out https://unsplash.com for options).
We want this image to be pretty big. In fact, we want this to be a full-screen image so that when people visit our website, they’ll think, “Wow, look at this great photography. It takes a lot of artistic vision to pick out a high-quality, well-composed landscape photo from a website. I like this guy or gal or human being with no attachment to gendered pronouns.” To do that, we’re going to add a descriptive class to our container and then give our container the background-image of whatever photo we chose:
Now let’s get some text on the screen. Create a new row inside your container, and inside the row add a 12-width column and give it an additional class of header. Then add a greeting in your language of choice. Mine’s English.
Okay, now let’s style it to get it looking a bit better. In your CSS document, add rules to the header to get the greeting to be aligned center, then shift it down about 40% of the view height from the top. We should also change the color so it’s a bit more visible against the background. Oh! And let’s also make the text bigger, and bump up the font-weight a little. You know how to do all that, don’t you?
Dang, look at that! It’s so simple and understated! It’s so clean! It’s so minimal (feel free to jump in with any other design jargon terms you know)! So Bauhaus! So Swiss!
Okay, hotshot, we’re not quite done yet (well if all you’re looking for is a website that says “hello” against a mountain landscape, then I guess at this point you are done). Let’s go ahead and add a little description paragraph so visitors know who built this thing.
We’ll want to contain our description in a new row, so we’ll do just that. The description itself might be a little long depending on the length of your name and how important you think you are, so we should think about how wide we want it to be. We probably want it to go across half the width of the screen at most for laptops and medium-sized computers. For really big computers, half the width of the screen is probably too big though--at that point we might want to limit it to a third of the screen. Although for phones, the full screen-width is probably okay.
See how useful it is to be able to delineate between screen sizes? If we clearly plan out how we want our website to look on each platform we can carefully account for each use case and ensure that everyone gets an equally beautiful website on their devices.
So let’s do just that. Are you ready? This is going to be a doozy.
I’ll go ahead and note right now that the col-sm-12 is redundant: one nice Bootstrap feature is that once the screen is resized to be smaller than the smallest column size explicitly accounted for in a div, that div will automatically become a 12-width column. For example, if we had a <div class='col-md-1'> </div>, that column would turn into a 12-width column once the screen classified as a small or extra-small. But while it is redundant to use col-sm-12, sometimes it’s nice to be explicit about what we’re doing so that people who have to look at our code after us (including our future selves) don’t get confused.
Alright, now let’s style this puppy or kitty or animal with no attachment to speciesed nouns. I think it’ll look cool with the same color text as we used in the header, a font-size of 2em, and centered text. Let’s check it out:
Hm. The text is centered, so that’s right, but it’s not centered in the right place. That’s because (on my screen at least) the description container spans six out of 12 columns, and not the full 12 like the header did, so the text will only be aligned within those six columns. We’ll need to shift the description column over somehow.
Bootstrap has a class for offsetting columns, and it works much in the same way as their column-sizing classes. Since our description spans six of the 12 columns in medium views, we’ll need to offset it by three in medium views to get it centered. In large views, since it’s four columns wide at that point, we’ll have to offset it by four. Double-check the math on that for me real quick (we don’t need to set an offset for the small size because, like how larger column sizing classes don’t apply to smaller screens, larger column-offsets don’t apply in smaller screens).
Perfect! But unless you’re very boring or a newborn you probably can’t describe your entire existence in two or three lines. We’ll go ahead and start a new section so you can digress to your heart’s content. Make a new container directly under your splash-image and populate it with a row. Inside that row, we’ll include two columns: one for an about section and another for a headshot.
In our smaller three-width column, let’s put our about section. Add an h1 tag and a p tag, and flesh out a more detailed description about yourself. You know, what you like and what you stand for. That stuff.
On your nine-width column, add an img tag with your headshot.
The img tag on its own doesn’t look quite right, so we’ll add a class to it and modify it in our CSS file.
Sweeeeet. But now’s the time for the moment of truth: how does it look when we resize our screen?
Hey, check that out! The widths of our columns changed as the screen shrunk, and our image automatically went under the about section once there wasn’t any room for it on the side. That’s not half bad. In fact, I’d be willing to say it’s at least half good. Maybe even three-quarters good.
But we’re certainly not done. If not using Google Chrome to view your website, go ahead and download it. Once you have it, open your website in Google Chrome and right-click anywhere on the screen to select “Inspect Element.” Then, at the top left of the panel that showed up on the right of your screen, select the little phone icon (it should say “Toggle device mode” if you hover over it).
This is one of Google Chrome’s most powerful web debugging tools. You can use it to emulate different devices on your computer, each having different screen sizes and resolutions. On the top-left of your browser window, you should now see a drop-down menu with the word “Devices” next to it. From that drop-down menu you can select from a variety of pre-set devices. Just for kicks, let’s pick the iPhone 6 option. What happens?
All of a sudden, our text is super tiny. We set it to 9em--why is it so small all of a sudden when it was so big on our computer? And not only is that text tiny, but so is everything else.
This happens because screens and devices come not only in different sizes, but also in different resolutions and pixel ratios as well. A screen’s resolution is essentially the number of pixels it can display (usually something like 1280x720 or 1920x780).
The pixel ratio is the relationship between physical pixels (the actual screen size) and logical pixels (how the screen size is interpreted by CSS). A iPhone 5s, for example, has a screen resolution of 640x1136 pixels. Its CSS pixel ratio, however, is 2, so when loading websites the browser determines its resolution to be 320x568 (half its real screen resolution in both measurements).
Pixel ratios were invented because without them websites would appear so small as to be unviewable. As mobile screens become more and more pixel-dense, a measurement of 200px becomes much smaller on a phone than it is on a computer.
To help alleviate this issue, CSS3 implemented a new feature known as media queries. These are rules within your CSS that are only triggered when certain conditions about the browser are met: what kind of device it’s being displayed on, how wide the window is, what the pixel ratio is, and things like that. Media queries allow you to be even more specific in how you target screens, and follow a rather simple format:
This is where Bootstrap’s “mobile-first” mantra comes in: you first design your website for mobile devices, and then you add media queries and other layout-affecting attributes to make sure your website still appears correctly on larger devices. With that in mind, let’s make a few changes to our website so it follows this convention. Don’t worry, we won’t be changing too much.
The first thing we should do is make the header a bit larger on our phones. If you look on the device preview, our header should look pretty small. In your CSS file, bump up the font-size to 15em.
We should do the same to our description. We’ll make it twice as big as it was before.
Now it looks better on our phone view, but how to does it check out on the desktop?
Yikes. Everything’s way too big. Don’t worry, This is where media queries come in.
Add a media query to target devices with a minimum width of 768px, and in that query apply rules to make our header and description font sizes what they were before we changed them.
There! Now if you switch your device setting to “Laptop with MDPI screen” or “Laptop with HDPI screen,” everything should still check out!
Now, a disclaimer: the media query we just put in won’t account for every screen size--you’ll notice that if you manually resize your browser with the website open it’ll break at one point, and the text will become much larger than you wanted it to. Making a website responsive and fit screens of every size does take some time and fiddling with media queries to get the right look at every size, and the breakpoints are different for every website. The best way to get familiar with your website’s natural breakpoints is just to play around with it and see what sizes are best for you.
Now that you understand the basics of responsive web design through Bootstrap, you can start adding sections to your website and begin to make it truly yours. If you’d like, you can also explore other responsive design frameworks, like Foundation or Google’s Material Design Lite (Google’s MDL is closer to a styling library than a full responsive design framework, and while it does have a similar grid-based system to Bootstrap or Foundation, it isn’t its main feature. MDL is also heavily styled to Google’s Material Design guidelines, and so if you’re not sure about committing to that look you may want to look elsewhere). There’s also much more to Bootstrap than just their responsive layouts--Bootstrap comes with a bunch of pre-built components (like a navbar). You can check out what they do and how to use them here.
It’s important to have the right tools to test responsive websites with, as sometimes websites on actual mobile devices will look different even from the same website on a resized desktop browser. To help you debug and test your responsive websites, Google Chrome has a great device mode feature that allows you to emulate many common screen sizes and devices. To use it, simply open your website in Google Chrome, then right click anywhere on the screen and select “Inspect Element.” This will pull up your HTML side-by-side with the actual website (inspect element is a great way to see how the browser is actually interpreting your code), and in the top left corner there should be a small phone icon. Click it to toggle device mode, and once it’s on you’ll be able to select devices of varying sizes, including phones, tablets, and even some desktops.


Sessions received
| Received from | Session notes | Attachment | Date |
|---|---|---|---|
| Tigran Hakobyan | Lorem ipsum dolor sit first line of Lorem Ipsum, lorem ipsum dolor sit amet., comes... View more | Document_name | 15.01.2019 |
| Hakob Manukyan | 22.02.2019 |
Sessions provided
| Provided to | Session notes | Attachment | Date |
|---|---|---|---|
| Tigran Hakobyan | Lorem ipsum dolor sit first line of Lorem Ipsum, lorem ipsum dolor sit amet., comes... View more | Document_name | 15.01.2019 |
| Hakob Manukyan | Add note | 22.02.2019 |


|
IVT
|
Camera model and functions for a stereo camera system. More...
#include <StereoCalibration.h>
Public Member Functions | |
| CStereoCalibration () | |
| The default constructor. More... | |
| ~CStereoCalibration () | |
| The destructor. More... | |
| CStereoCalibration (const CStereoCalibration &stereoCalibration) | |
| The copy constructor. More... | |
| void | Set (const CStereoCalibration &stereoCalibration) |
| Initializes the stereo camera model, given an instance of CStereoCalibration. More... | |
| void | SetSingleCalibrations (const CCalibration &leftCalibration, const CCalibration &rightCalibration, bool bTransformLeftCameraToIdentity=false) |
| Initializes the stereo camera model, given two instances of CCalibration. More... | |
| void | SetDistortionParameters (float d1_left, float d2_left, float d3_left, float d4_left, float d1_right, float d2_right, float d3_right, float d4_right) |
| Sets the distortion parameters of the distortion models of both cameras. More... | |
| void | SetExtrinsicParameters (const Mat3d &left_rotation, const Vec3d &left_translation, const Mat3d &right_rotation, const Vec3d &right_translation, bool bTransformLeftCameraToIdentity=false) |
| Sets the extrinsic parameters of both cameras. More... | |
| bool | LoadCameraParameters (const char *pCameraParameterFileName, bool bTransformLeftCameraToIdentity=true) |
| Initializes the stereo camera model, given a file path to a stereo camera parameter file. More... | |
| bool | SaveCameraParameters (const char *pCameraParameterFileName) const |
| Writes the parameters of the camera model to camera parameter file. More... | |
| const CCalibration * | GetLeftCalibration () const |
| Access to the instance of CCalibration for the camera model of the left camera. More... | |
| const CCalibration * | GetRightCalibration () const |
| Access to the instance of CCalibration for the camera model of the right camera. More... | |
| void | Calculate3DPoint (const Vec2d &cameraPointLeft, const Vec2d &cameraPointRight, Vec3d &worldPoint, bool bInputImagesAreRectified, bool bUseDistortionParameters=true, PointPair3d *pConnectionLine=0) |
| Computes a 3D point, given a point correspondence in both images, by performing stereo triangulation. More... | |
| void | CalculateEpipolarLineInLeftImage (const Vec2d &pointInRightImage, Vec3d &l) |
| Given an image point in the right image, computes the corresponding epipolar line in the left image. More... | |
| void | CalculateEpipolarLineInLeftImage (const Vec2d &pointInRightImage, PointPair2d &epipolarLine) |
| Given an image point in the right image, computes the corresponding epipolar line in the left image. More... | |
| void | CalculateEpipolarLineInLeftImage (const Vec2d &pointInRightImage, float &m, float &c) |
| Deprecated. More... | |
| void | CalculateEpipolarLineInRightImage (const Vec2d &pointInLeftImage, Vec3d &l) |
| Given an image point in the left image, computes the corresponding epipolar line in the right image. More... | |
| void | CalculateEpipolarLineInRightImage (const Vec2d &pointInLeftImage, PointPair2d &epipolarLine) |
| Given an image point in the left image, computes the corresponding epipolar line in the right image. More... | |
| void | CalculateEpipolarLineInRightImage (const Vec2d &pointInLeftImage, float &m, float &c) |
| Deprecated. More... | |
| float | CalculateEpipolarLineInLeftImageDistance (const Vec2d &pointInLeftImage, const Vec2d &pointInRightImage) |
| Given a point correspondence, computes the distance from the epipolar line in the left image. More... | |
| float | CalculateEpipolarLineInRightImageDistance (const Vec2d &pointInLeftImage, const Vec2d &pointInRightImage) |
| Given a point correspondence, computes the distance from the epipolar line in the right image. More... | |
| void | GetProjectionMatricesForRectifiedImages (Mat3d &P1Left, Vec3d &p2Left, Mat3d &P1Right, Vec3d &p2Right) const |
| Sets up the projection matrix P for the rectified images. More... | |
Public Attributes | |
| int | width |
| The width of the images of the stereo camera system in pixels. More... | |
| int | height |
| The height of the images of the stereo camera system in pixels. More... | |
| Mat3d | rectificationHomographyLeft |
| The homography for the rectification mapping of the right image. More... | |
| Mat3d | rectificationHomographyRight |
| The homography for the rectification mapping of the right image. More... | |
Camera model and functions for a stereo camera system.
Handles two instances of CCalibration to model a stereo camera system, computes the epipolar geometriy and performs stereo triangulation.
The camera model that is used for modeling the two individual cameras, including the extrinsic camera parameters, is described in detail in the documentation of the class CCalibration.
The instance can be initialized either by reading a stereo camera parameter file (LoadCameraParameters(const char*, bool) or by assigning two instances of CCalibration (SetSingleCalibrations(const CCalibration&, const CCalibration&, bool). It is possible to adapt the extrinsic parameters, so that the world coordinate system and the camera coordinate system of the left camera become equal.
After initialization, a 3D point can be calculated, given a point correspondence in the left and right camera image (Calculate3DPoint(const Vec2d&, const Vec2d&, Vec3d&, bool, bool, PointPair3d*). Furthermore, access to the epipolar lines is offered.
Definition at line 87 of file StereoCalibration.h.
| CStereoCalibration::CStereoCalibration | ( | ) |
The default constructor.
The default constructor initializes the stereo camera model with a standard camera setup with a baseline of 100 mm (no orientation difference, i.e. and ), where I denotes the 3x3 identity matrix..
The intrinsic parameters of the cameras are equal and are listed in CCalibration::CCalibration().
Definition at line 66 of file StereoCalibration.cpp.
| CStereoCalibration::~CStereoCalibration | ( | ) |
The destructor.
Definition at line 78 of file StereoCalibration.cpp.
| CStereoCalibration::CStereoCalibration | ( | const CStereoCalibration & | stereoCalibration | ) |
The copy constructor.
Definition at line 84 of file StereoCalibration.cpp.
| void CStereoCalibration::Calculate3DPoint | ( | const Vec2d & | cameraPointLeft, |
| const Vec2d & | cameraPointRight, | ||
| Vec3d & | worldPoint, | ||
| bool | bInputImagesAreRectified, | ||
| bool | bUseDistortionParameters = true , |
||
| PointPair3d * | pConnectionLine = 0 |
||
| ) |
Computes a 3D point, given a point correspondence in both images, by performing stereo triangulation.
| [in] | cameraPointLeft | The 2D point in the left image. |
| [in] | cameraPointRight | The 2D point in the right image. |
| [out] | worldPoint | The result 3D point in the world coordinate system. |
| [in] | bInputImagesAreRectified | If set to true, cameraPointLeft and cameraPointRight are transformed to the corresponding 2D points in the original images, so that the camera models can be applied. If set to false, cameraPointLeft and cameraPointRight must have been computed on non-rectified images. |
| [in] | bUseDistortionParameters | If set to true, the (inverse) distortion model will be applied before linear back projection, i.e. cameraPointLeft and cameraPointRight must contain distorted image coordinates. If set to false, the distortion model is skipped, i.e. cameraPointLeft and cameraPointRight must contain undistorted image coordinates. In other words: If the images in which the coordinates cameraPointLeft and cameraPoint right were calculate were undistorted beforehand then set this parameter to false, otherwise to true. |
| [out] | pConnectionLine | Optional output parameter for receiving the two endpoints of the shortest connection line between the two re-projected straight lines. The parameter worldPoint contains the center of this connection line. |
Definition at line 235 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInLeftImage | ( | const Vec2d & | pointInRightImage, |
| Vec3d & | l | ||
| ) |
Given an image point in the right image, computes the corresponding epipolar line in the left image.
The representation of the epipolar line is defined as:
.
All image points (u, v) lying on the epipolar line satisfy this equation. Note that is the normal vector the line.
| [in] | pointInRightImage | The 2D point in the right image. |
| [out] | l | A 3D vector representing the result epipolar line. It is l1 = l.x, l2 = l.y, l3 = l.z. |
Definition at line 304 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInLeftImage | ( | const Vec2d & | pointInRightImage, |
| PointPair2d & | epipolarLine | ||
| ) |
Given an image point in the right image, computes the corresponding epipolar line in the left image.
The epipolar line is represented by the two end points of the intersection with the image.
| [in] | pointInRightImage | The 2D point in the right image. |
| [out] | epipolarLine | Result parameter that contains the two end points. |
Definition at line 319 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInLeftImage | ( | const Vec2d & | pointInRightImage, |
| float & | m, | ||
| float & | c | ||
| ) |
Deprecated.
This function is deprecated. Use CalculateEpipolarLineInLeftImage(const Vec2d&, Vec3d&) or CalculateEpipolarLineInLeftImage(const Vec2d&, PointPair2d&) instead.
Models the line as . This representation fails for vertical lines.
Definition at line 310 of file StereoCalibration.cpp.
| float CStereoCalibration::CalculateEpipolarLineInLeftImageDistance | ( | const Vec2d & | pointInLeftImage, |
| const Vec2d & | pointInRightImage | ||
| ) |
Given a point correspondence, computes the distance from the epipolar line in the left image.
Given pointInRightImage, computes the corresponding epipolar in the left image and the computes the distance of pointInLeftImage to it.
| [in] | pointInLeftImage | The 2D point in the left image. |
| [in] | pointInRightImage | The 2D point in the right image. |
Definition at line 394 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInRightImage | ( | const Vec2d & | pointInLeftImage, |
| Vec3d & | l | ||
| ) |
Given an image point in the left image, computes the corresponding epipolar line in the right image.
The representation of the epipolar line is defined as:
.
All image points (u, v) lying on the epipolar line satisfy this equation. Note that is the normal vector the line.
| [in] | pointInLeftImage | The 2D point in the left image. |
| [out] | l | A 3D vector representing the result epipolar line. It is l1 = l.x, l2 = l.y, l3 = l.z. |
Definition at line 349 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInRightImage | ( | const Vec2d & | pointInLeftImage, |
| PointPair2d & | epipolarLine | ||
| ) |
Given an image point in the left image, computes the corresponding epipolar line in the right image.
The epipolar line is represented by the two end points of the intersection with the image.
| [in] | pointInLeftImage | The 2D point in the right image. |
| [out] | epipolarLine | Result parameter that contains the two end points. |
Definition at line 364 of file StereoCalibration.cpp.
| void CStereoCalibration::CalculateEpipolarLineInRightImage | ( | const Vec2d & | pointInLeftImage, |
| float & | m, | ||
| float & | c | ||
| ) |
Deprecated.
This function is deprecated. Use CalculateEpipolarLineInRightImage(const Vec2d&, Vec3d&) or CalculateEpipolarLineInRightImage(const Vec2d&, PointPair2d&) instead.
Models the line as . This representation fails for vertical lines.
Definition at line 355 of file StereoCalibration.cpp.
| float CStereoCalibration::CalculateEpipolarLineInRightImageDistance | ( | const Vec2d & | pointInLeftImage, |
| const Vec2d & | pointInRightImage | ||
| ) |
Given a point correspondence, computes the distance from the epipolar line in the right image.
Given pointInLeftImage, computes the corresponding epipolar in the right image and the computes the distance of pointInRightImage to it.
| [in] | pointInLeftImage | The 2D point in the left image. |
| [in] | pointInRightImage | The 2D point in the right image. |
Definition at line 407 of file StereoCalibration.cpp.
|
inline |
Access to the instance of CCalibration for the camera model of the left camera.
Definition at line 211 of file StereoCalibration.h.
| void CStereoCalibration::GetProjectionMatricesForRectifiedImages | ( | Mat3d & | P1Left, |
| Vec3d & | p2Left, | ||
| Mat3d & | P1Right, | ||
| Vec3d & | p2Right | ||
| ) | const |
Sets up the projection matrix P for the rectified images.
The projection matrix P for an image that was rectified according to the homography H is a 3x4 matrix defined as:
, where K denotes the calibration matrix (see CCalibration::GetCalibrationMatrix), R and t are the extrinsic parameters, and H is the homography that maps undistorted image coordinates to rectified image coordinates.
Note that in the case of the left camera H is the inverse of CStereoCalibration::rectificationHomographyLeft, and in the case of the right camera H is the inverse of CStereoCalibration::rectificationHomographyRight.
The camera model is described in the general information about the class CCalibration.
| [out] | P1Left | The left 3x3 part of the projection matrix for the left camera, i.e. P1Left = H_left K_left R_left. |
| [out] | p2Left | The right 3x1 part of the projection matrix for the right camera, i.e. p2Left = H_left K_left t_left. |
| [out] | P1Right | The left 3x3 part of the projection matrix for the right camera, i.e. P1Right = H_right K_right R_right. |
| [out] | p2Right | The right 3x1 part of the projection matrix for the right camera, i.e. p2Right = H_right K_right t_right. |
Definition at line 583 of file StereoCalibration.cpp.
|
inline |
Access to the instance of CCalibration for the camera model of the right camera.
Definition at line 214 of file StereoCalibration.h.
| bool CStereoCalibration::LoadCameraParameters | ( | const char * | pCameraParameterFileName, |
| bool | bTransformLeftCameraToIdentity = true |
||
| ) |
Initializes the stereo camera model, given a file path to a stereo camera parameter file.
The format of the file is the same as the one used in OpenCV 1.0. It is...
Camera calibration can be performed with the application found in IVT/examples/CalibrationApp (resp. IVT/win32/CalibrationApp). See also the class CDLTCalibration.
| [in] | pCameraParameterFileName | The file path to the camera parameter file to be loaded. |
| bTransformLeftCameraToIdentity | If set to true, then the extrinsic parameters will be adapted so that the extrinsic parameters of the left camera become the identiy mapping, i.e. and , where I denotes the 3x3 identity matrix. That means that the world coordinate systems and the camera coordinate system of the left camera become equal. If set to false, the extrinsic parameters are not changed. Note that the internal fundamental matrix for the epipolar geometry is not affected by the choice of this flag. |
Definition at line 421 of file StereoCalibration.cpp.
| bool CStereoCalibration::SaveCameraParameters | ( | const char * | pCameraParameterFileName | ) | const |
Writes the parameters of the camera model to camera parameter file.
The format of the file is the same as the one used in OpenCV 1.0. The file format is described in LoadCameraParameters(const char*, bool).
In the following specification of the file format, the first row of each double row contains the parameters of the first, i.e. left, camera, and the second row the parameters of the right camera, respectively. The parameter denotes the number of cameras.
n
w h fx 0 cx 0 fy cy 0 0 1 d1 d2 d3 d4 r1 r2 r3 r4 r5 r6 r7 r8 r9 t1 t2 t3
w h fx 0 cx 0 fy cy 0 0 1 d1 d2 d3 d4 r1 r2 r3 r4 r5 r6 r7 r8 r9 t1 t2 t3
u1 v1 u2 v2 u3 v3 u4 v4
u1 v1 u2 v2 u3 v3 u4 v4
a1 a2 a3 a4 a5 a6 a7 a8 a9
a1 a2 a3 a4 a5 a6 a7 a8 a9
For each camera, the parameters w and h denote the width and height, respectively. The next nine parameters define the calibration matrix (see CCalibration::GetCalibrationMatrix). The parameters d1-d4 denote the distortion parameters of the distortion model, the extrinsic parameters r1-r9 define the rotation matrix R and t1-t3 the translation vector t (see camera model description in the documentation of the class CCalibration). These parameters of both cameras fully describe the epipolar geometry.
The parameters (u1, v1), ..., (u4, v4) define the corner points of the destination quadrangle after rectification. These parameters are not necessary (and redundant) and are therefore not read by the IVT.
Finally, the rectification parameters a1-a9 specify the 3x3 homography matrix A. This homography computes the image coordinates in the original image for given image coordinates in the rectified images. It can thus be directly used to compute a lookup table for the mapping, which is implemented efficiently by the class CRectification.
| [in] | pCameraParameterFileName | The file path to the target camera parameter file. |
Definition at line 509 of file StereoCalibration.cpp.
| void CStereoCalibration::Set | ( | const CStereoCalibration & | stereoCalibration | ) |
Initializes the stereo camera model, given an instance of CStereoCalibration.
| stereoCalibration | The template instance. |
Definition at line 106 of file StereoCalibration.cpp.
| void CStereoCalibration::SetDistortionParameters | ( | float | d1_left, |
| float | d2_left, | ||
| float | d3_left, | ||
| float | d4_left, | ||
| float | d1_right, | ||
| float | d2_right, | ||
| float | d3_right, | ||
| float | d4_right | ||
| ) |
Sets the distortion parameters of the distortion models of both cameras.
| [in] | d1_left | The first radial lens distortion parameter of the left camera. |
| [in] | d2_left | The second radial lens distortion parameter of the left camera. |
| [in] | d3_left | The first tangential lens distortion parameter of the left camera. |
| [in] | d4_left | The second tangential lens distortion parameter of the left camera. |
| [in] | d1_right | The first radial lens distortion parameter of the right camera. |
| [in] | d2_right | The second radial lens distortion parameter of the right camera. |
| [in] | d3_right | The first tangential lens distortion parameter of the right camera. |
| [in] | d4_right | The second tangential lens distortion parameter of the right camera. |
Definition at line 121 of file StereoCalibration.cpp.
| void CStereoCalibration::SetExtrinsicParameters | ( | const Mat3d & | left_rotation, |
| const Vec3d & | left_translation, | ||
| const Mat3d & | right_rotation, | ||
| const Vec3d & | right_translation, | ||
| bool | bTransformLeftCameraToIdentity = false |
||
| ) |
Sets the extrinsic parameters of both cameras.
The member variables CCalibration::m_rotation_inverse and CCalibration::m_translation_inverse for both cameras are updated automatically.
| [in] | left_rotation | The rotation matrix for the left camera as part of the extrinsic camera parameters. |
| [in] | left_translation | The translation vector for the left camera as part of the extrinsic camera parameters. |
| [in] | right_rotation | The rotation matrix for the right camera as part of the extrinsic camera parameters. |
| [in] | right_translation | The translation vector for the right camera as part of the extrinsic camera parameters. |
| bTransformLeftCameraToIdentity | If set to true, then the extrinsic parameters will be adapted so that the extrinsic parameters of the left camera become the identiy mapping, i.e. and , where I denotes the 3x3 identity matrix. That means that the world coordinate systems and the camera coordinate system of the left camera become equal. If set to false, the extrinsic parameters are not changed. Note that the internal fundamental matrix for the epipolar geometry is not affected by the choice of this flag. |
Definition at line 165 of file StereoCalibration.cpp.
| void CStereoCalibration::SetSingleCalibrations | ( | const CCalibration & | leftCalibration, |
| const CCalibration & | rightCalibration, | ||
| bool | bTransformLeftCameraToIdentity = false |
||
| ) |
Initializes the stereo camera model, given two instances of CCalibration.
| leftCalibration | The template instance for the left camera. |
| rightCalibration | The template instance for the right camera. |
| bTransformLeftCameraToIdentity | If set to true, then the extrinsic parameters will be adapted so that the extrinsic parameters of the left camera become the identiy mapping, i.e. and , where I denotes the 3x3 identity matrix. That means that the world coordinate systems and the camera coordinate system of the left camera become equal. If set to false, the extrinsic parameters are not changed. Note that the internal fundamental matrix for the epipolar geometry is not affected by the choice of this flag. |
Definition at line 127 of file StereoCalibration.cpp.
| int CStereoCalibration::height |
The height of the images of the stereo camera system in pixels.
Definition at line 348 of file StereoCalibration.h.
| Mat3d CStereoCalibration::rectificationHomographyLeft |
The homography for the rectification mapping of the right image.
Given a point in the rectified image, applying this homography computes the corresponding point in the original image (see also Math2d::ApplyHomography).
This member variable is only valid if the method LoadCameraParameters(const char*, bool) was used for initialization.
Use StereoCalibrationCV::CalculateRectificationHomographies if any other method was used for initialization and this member is needed (mainly if the class CRectification is to be used).
Definition at line 359 of file StereoCalibration.h.
| Mat3d CStereoCalibration::rectificationHomographyRight |
The homography for the rectification mapping of the right image.
Given a point in the rectified image, applying this homography computes the corresponding point in the original image (see also Math2d::ApplyHomography).
This member variable is only valid if the method LoadCameraParameters(const char*, bool) was used for initialization.
Use StereoCalibrationCV::CalculateRectificationHomographies if any other method was used for initialization and this member is needed (mainly if the class CRectification is to be used).
Definition at line 370 of file StereoCalibration.h.
| int CStereoCalibration::width |
The width of the images of the stereo camera system in pixels.
Definition at line 346 of file StereoCalibration.h.


Google Earth Enterprise Documentation Home | GEE Server administration
Create composite globes and maps
Contents
Introduction
A composite globe (.glc
) is an assembly of layers from existing portable globes or maps. A portable globe or map stores all the geospatial data available within your specified area of interest—your cut—including all high-resolution imagery, terrain, vector data, KML files, and searchable point of interest (POI) locations. Outside the specified area of interest, the globe or map stores only low-resolution imagery and terrain. You specify the levels of resolution when you cut the globe or map.
When you create a composite globe or map, you define your viewing area using a KML polygon, select layers, and in addition for globes, specify base globe options. One of the key benefits of using composite maps and globes is that you can apply layers that use different cuts or regions of interest, then assemble them to create one single portable map or globe.
For example, you may want to create a composite map for a hiking trip. You might cut a road map using one region of interest and then cut imagery and also a park map of the hiking trail using additional regions of interest. Ordinarily, cuts from map databases would result in separate .glm
files. By assembling the .glm
files into a composite .glc
file, the result is a single portable map.
Creating composite maps and globes
You can create composite files of portable globes and maps with the Assembly tool feature of the Google Earth Enterprise (GEE) Server. You provide a KML polygon definition to identify the ‘area of interest.’ This polygon not only defines the viewing area, but is also used by Fusion to create a localized search database.
You select 2D or 3D layers to add to the composite file from any of the cut maps or globes that you have available in your /opt/google/gehttpd/htdocs/cutter/globes
directory. In addition, for globes, you specify a base globe.
New .glc
files are added to the default /opt/google/gehttpd/htdocs/cutter/globes
directory. If you want to change the location of your portable files directory, see Serving a globe or map from GEE Server.
If you want to extract the 2D or 3D layers from a composite .glc file, you use the Disassembly tool, specifying a target directory for the extracted files.
To assemble a composite map or globe:
- Access the Google Earth Enterprise Server Admin console in a browser window by going to myserver.mydomainname.com/admin, replacing myserver and mydomainname with your server and domain.
- Sign in with the default credentials or the username and password assigned to you:
- Default username: geapacheuser
- Default password: geeadmin
Note: If you do not know your username and password, contact your Google Earth Enterprise Server System Administrator. Click Dashboard to view information about the portable files registered on and published to the Server.
- Click the Settings button in the top right of the window and choose Glc Assembly from the Tools menu. The GLC Assembly tool window appears.
- Enter a name for the offline map or globe.
The name defines the filename for your composite map or globe. Composite maps and globes are created as .glc files. Spaces, slashes, and double dots (..) will be converted to underscores in the saved map or globe name.
- Enter a description to be associated with the composite file.
The description appears in the list of portable files in Portable when you click the Folder icon and also on the Dashboard page in the GEE Server admin console.
- Provide a KML polygon to define your ‘area of interest,’ including the definition of your localized search database.
- Choose either 2D or 3D to see a list of the available layers from the maps and globes you have available in your /opt/google/gehttpd/htdocs/cutter/globes directory.
- Click the Layers drop-down list to select a layer to add to your composite file. The selected layer appears as Layer 1. Check the Use Search? box to include a localized search database with this layer.
- To add more layers, click the Layers drop-down list and continue to select from your available maps or globes.
Select the layers in the order that you want them to appear in your portable globe or map. If you need to remove a layer, click delete.
When you have no more layers available, the Layers drop-down list indicates that all available layers are in use.
For composite maps, once you have assembled the layers you want to include, click Assemble Glc.
For composite globes, you select a base globe and apply options to it.
This option only affects the imagery layer within older .glb
files.
Extracting layers from a composite map or globe
If you want to extract the 2D or 3D layers from a composite .glc
file, you use the Glc Disassembly tool, specifying a target directory for the extracted files.
To disassemble a composite file:
- Access the Google Earth Enterprise Server Admin console in a browser window by going to myserver.mydomainname.com/admin, replacing myserver and mydomainname with your server and domain.
- Sign in with the default credentials or the username and password assigned to you:
- Default username: geapacheuser
- Default password: geeadmin
Note: If you do not know your username and password, contact your Google Earth Enterprise Server System Administrator. Click Dashboard to view information about the portable files registered on and published to the Server.
- Click the Settings button in the top right of the window and choose Glc Disassembly from the Tools menu. The GLC disassembly tool window appears.
- Click open the Glc path drop-down list to select a composite file to disassemble.
By default, the Glc path is the /opt/google/gehttpd/htdocs/cutter/globes directory, where all portable maps and globes are stored.
- Enter a new output directory in the text box.
- Click Disassemble glc.
The layers in the composite file are extracted and are moved to the output directory that you specified. If you included a base globe, this portable file is also output to the same directory.


Welcome, You have logged in successfully
Click here for admin page!(Edit Cookie to 'admin' for full accses
Back to Login page.


Mandarin Chinese Phonetic Segmentation and Tone, Linguistic Data Consortium (LDC) Catalog Number LDC2015S05 and ISBN 1-58563-710-6, was developed by LDC and contains 7,849 Mandarin Chinese "utterances" and their phonetic segmentation and tone labels separated into training and test sets. The utterances were derived from 1997 Mandarin Broadcast News Speech and Transcripts (HUB4-NE) (LDC98S73 and LDC98T24, respectively). That collection consists of approximately 30 hours of Chinese broadcast news recordings from Voice of America, China Central TV and KAZN-AM, a commercial radio station based in Los Angeles, CA.
The ability to use large speech corpora for research in phonetics, sociolinguistics and psychology, among other fields, depends on the availability of phonetic segmentation and transcriptions. This corpus was developed to investigate the use of phone boundary models on forced alignment in Mandarin Chinese. Using the approach of embedded tone modeling (also used for incorporating tones for automatic speech recognition), the performance on forced alignment between tone-dependent and tone-independent models was compared.
Utterances were considered as the time-stamped between-pause units in the transcribed news recordings. Those with background noise, music, unidentified speakers and accented speakers were excluded. A test set was developed with 300 utterances randomly selected from six speakers (50 utterances for each speaker). The remaining 7,549 utterances formed a training set.
The utterances in the test set were manually labeled and segmented into initials and finals in Pinyin, a Roman alphabet system for transcribing Chinese characters. Tones were marked on the finals, including Tone1 through Tone4, and Tone0 for the neutral tone. The Sandhi Tone3 was labeled as Tone2. The training set was automatically segmented and transcribed using the LDC forced aligner, which is a Hidden Markov Model (HMM) aligner trained on the same utterances (Yuan et al. 2014). The aligner achieved 93.1% agreement (of phone boundaries) within 20 ms on the test set compared to manual segmentation. The quality of the phonetic transcription and tone labels of the training set was evaluated by checking 100 utterances randomly selected from it. The 100 utterances contained 1,252 syllables: 15 syllables had mistaken tone transcriptions; two syllables showed mistaken transcriptions of the final, and there were no syllables with transcription errors on the initial.
Each utterance has three associated files: a flac compressed wav file, a word transcript file, and a phonetic boundaries and label file.
Please see file.tbl for a complete file list as well as checksums for this publication.
This work was supported in part by National Science Foundation Grant No. IIS-0964556.
Additional information, updates, bug fixes may be available in the LDC catalog entry for this corpus at LDC2015S05.
Portions © 1997 China Central TV, © 1997 MultiCultural Broadcasting Corporation, © 1997, 1998, 2007, 2015 Trustees of the University of Pennsylvania


W
elcome
E
veryone
Home
Portfolio
Projects
Data Analysis
Predective Modeling
Contact
Hello,
I am Aritra
Software Developer
Portfolio
I
am
a btech undergrad at kiit university
High School
Secondary School
My Likings
My Passion
Recent
Projects
Line Crawler
Home Automation
Data Science
My work on
Data Analytics
More
Predective
Modeling
History
More
Contact
info
Phone
+91<PHONE_NUMBER>
Email
<EMAIL_ADDRESS>Address
Bardhamaan, Bengal , India


The JavaScript language was created in 1995, initially developed in May and released to the public in December of that same year. Thus, 2020 marks its 25th Anniversary--certainly a huge milestone for this language that has become one of the most popular.
The 25th Anniversary of JavaScript presents itself as a great opportunity for the community to look back in history and forward towards the future. What were the major milestones that marked its history and how will this already popular language evolve even further?
The language itself and the community behind it has a rich history. JavaScript has been key to the formation of the World Wide Web. Organizations like the Mozilla Foundation, the W3C, and Ecma have played a major role in developing the language, and projects like jQuery and Node.js have contributed significantly in demonstrating JavaScript’s potential capabilities both on the client side as well on the server side.
As for the future of JavaScript, one thing is clear: collaboration is key. The “Browser Wars” have come and gone, and neither users nor developers want to relive the problems brought by the lack of interoperability. Fortunately, open source has prevailed and represents the way forward in terms of development and governance of the JavaScript language and community.
To celebrate the 25 years of JavaScript, please find below the top milestones that have shaped its history:
While working at CERN, Tim Berners-Lee laid out his vision for what would become the web in a document called "Information Management: A Proposal." [Read More]
The first website went live on August 6, 1991. It was dedicated to the World Wide Web project itself and was hosted on Tim Berners-Lee's NeXT computer. [Read More]
NCSA Mosaic was the web browser that popularized the World Wide Web. Marc Andreessen and Eric Bina developed Mosaic while at NCSA at the University of Illinois at Urbana–Champaign. It was first published in June 1993. [Read More]
Marc Andreessen and Jim Clark founded what would become Netscape Communications Corporation and launched their first browser on September 9, 1994. Originally it was called Mosaic Netscape, but it was renamed as Netscape Navigator to avoid trademark problems with NCSA. The internal codename for the browser was Mozilla, which stood for "Mosaic killer" and indeed it rapidly became the most popular browser. [Read More]
Marc Andreessen imagined a more dynamic Web and believed that a language easy to use by Web designers was needed. He recruited Brendan Eich, who in 10 days wrote a prototype for the Netscape browser in May 1995. The language was first called Moca, later LiveScript, and finally renamed JavaScript (to serve as a companion language to Java). The official public announcement of JavaScript was on December 4, 1995. [Read More]
Microsoft reverse-engineered Netscape's JavaScript to create JScript and made it part of Internet Explorer 3. The introduction of proprietary, non-standards-compliant extensions made it difficult for developers to make a single website that worked well in all browsers. Eventually Internet Explorer became the dominant software in the browser wars. [Read More]
Netscape submitted JavaScript to ECMA International to create a standard specification, which other browser vendors could then implement. This led to the official release of the language specification ECMAScript in June 1997. [Read More]
On January 23, 1998, with a steep drop in the browser market share, Netscape announced that it would release the source code of Netscape Communicator 5.0 in the hopes that it would become a popular open source project. That's how the Mozilla project was born. [Read More]
Microsoft shipped a primordial form of XMLHttpRequest with Internet Explorer 5.0 in March 1999. XMLHttpRequest is an API to transfer data between a web browser and a web server which would prove useful in the future. [Read More]
This edition added regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and other enhancements. This was the edition that prevailed for a decade due to stagnation of ECMAscript 4. [Read More]
Douglas Crockford specified JSON (JavaScript Object Notation), a lightweight data-interchange format based on a subset of JavaScript. JSON data is easier to load and work with in the frontend, and by the end of the decade would supersede XML as a data-interchange format on the Web. [Read More]
Firefox began as an experimental branch of the Mozilla project by Dave Hyatt, Joe Hewitt, and Blake Ross in 2002. To combat what they saw as the Mozilla Suite's software bloat, they created a stand-alone browser, first named Phoenix, later Firebird, and finally Firefox. Firefox version 1.0 was released on November 9, 2004. Firefox's speed, usability, and marketing helped it gain market share against Internet Explorer. Within five years of launching, Firefox accounted for nearly a third of all web browsing. [Read More]
Jesse James Garrett coined the term AJAX (Asynchronous JavaScript + XML) to describe the asynchronous technologies behind emerging web applications like GMail and Google Maps, which allowed web pages to change content dynamically without the need to reload. [Read More]
jQuery is a JavaScript library that was designed by John Resig to simplify HTML DOM tree traversal and manipulation, as well as event handling, CSS animation, and AJAX. Other JavaScript frameworks/libraries launched during this period include Mootools and Prototype. [Read More]
Google released the Chrome browser on December 11, 2008, using the same WebKit rendering engine as Safari and a faster JavaScript engine called V8. Shortly after, an open-sourced version for the Windows, OS X, and Linux platforms was released under the name Chromium. With a rapid release cycle and a focus on speed, Google Chrome eventually overtook all other browsers. [Read More]
Node.js was initially developed by Ryan Dahl in March 2009 based on Google's open source V8 JavaScript engine. It paved way to the use of JavaScript on Web servers. Node.js functions are non-blocking, allowing the server to handle a high load of concurrent connections. It represents a 'JavaScript everywhere' paradigm, unifying web-application development around a single programming language. [Read More]
npm (originally short for Node Package Manager) is a package manager for the JavaScript programming language developed by Isaac Z. Schlueter. The npm Registry is a public collection of packages of open-source code for Node.js, front-end web apps, mobile apps, and other applications. [Read More]
ECMAScript 5, the incremental upgrade to ECMAScript 3, was released in December 2009, more than a decade after ECMAScript 3. The ambitious ECMAScript 4 was officially abandoned and under the codenamed Harmony some features became ECMAScript 6. Other features of the original ECMAScript 4 plan would be dropped to be adopted in subsequent versions. A renewed resolve was formed that any new ideas would be developed with the consensus of the entire TC39 in order to prevent the potential for future schisms. [Read More]
AngularJS was released in October 2010 by Misko Hevery and it quickly became the most popular JavaScript MVC framework. It offered two-way data binding, dependency injection, routing package and much more. Other JavaScript frameworks/libraries launched during this period include Backbone, Ember, and Knockout. The project was succeeded by Angular in 2016, a complete rewrite of AngularJS led by the Angular Team at Google. [Read More]
React is a JavaScript library for building composable user interfaces developed by Jordan Walke and open-sourced in 2013. It's maintained by Facebook and a community of individual developers and companies. [Read More]
Vue.js is an open-source model–view–viewmodel front end JavaScript framework for building user interfaces and single-page applications created by Evan You. The first source code commit to the project was dated July 2013, and Vue was first released the following February, in 2014. [Read More]
Next.js is an open-source React framework created by Vercel. It uniquely satisfies the needs of both static and dynamic websites and applications. Next.js’ Incremental Static Regeneration gives users all the capabilities of a Static Site Generator, with the ability to add infinite numbers of pages and update them later – without rebuilding the entire site. [Read More]
Svelte is a free and open-source front end JavaScript framework created by Rich Harris. Svelte runs at build time, converting components into highly efficient imperative code that surgically updates the DOM. [Read More]
WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine. Wasm is designed as a portable target for compilation of high-level languages like C/C++/Rust, enabling deployment on the web for client and server applications. The precursor technologies were asm.js from Mozilla and Google Native Client. [Read More]
The OpenJS Foundation was formed from a merger of the JS Foundation and the Node.js Foundation in March 2019. The mission of the OpenJS Foundation is to support the healthy growth of JavaScript and web technologies by providing a neutral organization to host and sustain projects, as well as collaboratively fund activities that benefit the ecosystem as a whole. [Read More]
Deno is a runtime for JavaScript and TypeScript that is based on the V8 JavaScript engine and the Rust programming language. It was created by Ryan Dahl, original creator of Node.js. It was announced by him on JSConf EU 2018 in his talk "10 Things I Regret About Node.js". Deno explicitly takes on the role of both runtime and package manager within a single executable, rather than requiring a separate package-management program. [Read More]


Classes
The following classes are available globally.
-
Custom date formatter corresponds with the Dropmark API formatted date strings
See moreDeclaration
Swift
public class DKDateFormatter : DateFormatter
-
Provides encryption, decryption, and removal of an authenticated user object in the device keychain.
See moreDeclaration
Swift
@objc public class DKKeychain : NSObject
-
Memory-based storage for credentials within the current app session. Must be reconfigured every time the app leaves memory.
See moreDeclaration
Swift
@objc public class DKSession : NSObject
-
Collections are the main way things are organized in Dropmark. A collection has one owner, but has many items and users (AKA collaborators).
See moreDeclaration
Swift
@objc(DKCollection) public final class DKCollection : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable
-
Comments can be added to individual items.
See moreDeclaration
Swift
@objc(DKComment) public final class DKComment : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable
-
Undocumented
See moreDeclaration
Swift
public final class DKInvite : NSObject, DKResponseObjectSerializable, DKResponseListSerializable
-
Items belong to a collection, can optionally belong to another item (a stack), and have many comments and reactions.
See moreDeclaration
Swift
@objc(DKItem) public final class DKItem : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable
-
In a collection, the permissions represent what actions the current user can and cannot perform.
See moreDeclaration
Swift
@objc(DKPermissions) public class DKPermissions : NSObject, NSCoding
-
Reactions are essentially a way for a user to “Like” an item.
See moreDeclaration
Swift
@objc(DKReaction) public final class DKReaction : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable
-
Tags are added to items and are a great way to organize items across many collections.
See moreDeclaration
Swift
@objc(DKTag) public final class DKTag : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable
-
Teams are similar to a user account – they have their own username, dashboard and subscription, but a team can be managed by multiple users.
A user associated with a team can be a manager or a user. Managers have more privledges than a normal user and some API endpoints are limited to managers only.
Teams can be added to a collection as a collaborator by
See moreusername
oruser_id
(use the teamid
for this).Declaration
Swift
@objc(DKTeam) public final class DKTeam : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable, DKAccount
-
Represents the available thumbnails for a collection or item.
See moreDeclaration
Swift
@objc(DKThumbnails) public class DKThumbnails : NSObject, NSCoding
-
Represents a user on Dropmark. Can be the current user, collaborators, or users external to your team.
See moreNote
Only when a user is retrieved from the/auth
API endpoint will atoken
be returnedDeclaration
Swift
@objc(DKUser) public final class DKUser : NSObject, NSCoding, DKResponseObjectSerializable, DKResponseListSerializable, DKAccount
-
Use this class to load consecutive “pages” of content from a listable API endpoint. Includes utilities to check for new content while scrolling in a UICollectionView, UITableView, NSCollectionView, or NSTableView.
See moreDeclaration
Swift
public class DKPagingGenerator<T>


Before diving into the specifics of Gremlin, its good to know what you are getting yourself into. Moreover, it’s important to know if Gremlin can be of use to you. Below is a list of a few key reasons to use Gremlin.
- Gremlin is useful for manually working with your graph: You can use the Gremlin console like a file system prompt (see Basic Graph Traversals). You can navigate the graph, update vertex properties, add an edge, remove a vertex, etc. Gremlin is handy for graph maintenance and ensuring the integrity of your data. There is nothing worse than realizing that it’s not your code, but your data that is bugged.
- Gremlin allows you to query a graph: As you work with Gremlin, you will notice that many types of queries can be expressed in Gremlin in a much more succinct and understandable manner than with traditional programming languages. If you are building an application that requires a graph query, then it might be best to use the Gremlin evaluator in your application.
- Gremlin can express complex graph traversals succinctly: Similar to what was stated previously, Gremlin can express in a few lines of code what it would take many, many lines of code in Java to express (see User Defined Steps). Moreover, Gremlin was designed to represent complex graph traversals. Even today’s graph databases, frameworks, and packages lack the ability to express complex graph traversals — something Gremlin can do very elegantly.
- Gremlin is useful for exploring and learning about graphs: There are many add-ons/connectors for Gremlin that make it a unique environment for playing with graphs. Gremlin comes with a connector to the JUNG algorithms package, to the SPARQL query language, etc.
- Gremlin allows you to explore the Semantic Web/Web of Data: Gremlin can be used with RDF graphs. Moreover, Gremlin has a connector to LinkedData Sail which allows you to work with the Semantic Web/Web of Data in real-time.
- Gremlin ensures that you are not tied to a particular graph backend: Gremlin can be used over various graph databases. Thus, you can make use of your same Gremlin code even when you change your graph database backend (see Blueprints).
- Gremlin allows for universal path-based computations: Gremlin allows you to control, to the utmost degree, the execution of a traversal within a graph. This provides the flexibility to create sophisticated ways in which to analyze, query, and manipulate a graph.
- Gremlin is extensible and can be oriented to your particular use case: It is possible to extend Gremlin with new methods and steps defined natively in Gremlin or in Java (see User Defined Steps). Moreover, it’s possible to add other graph backends by implementing the graph interfaces provided by Blueprints.
- Gremlin uses the Java API: The host virtual machine for Gremlin is the Java Virtual Machine. Gremlin code can take advantage of the Java API. In this way, Gremlin and Java work seamlessly together.
- Gremlin is embedded in various JVM languages: The core of Gremlin is written in Java. However, Gremlin distributes with native language constructs for the JVM language Groovy. In this way, Gremlin is more a traversal style than a language as other JVM languages can naturally host it.
- Gremlin is Turing complete: Many graph traversal languages can only recognize regular paths through a graph. Gremlin provides numerous memory and computing constructs to support arbitrary path recognition.


|
|
| 07/02/1997 |
|
This is a simple program that just lists the COM ports section of the BIOS
Data Area.
Download [5 K]
|
Source [2 K]
GitHub Repo
|
|
| 28/12/1995 |
|
This is a User-Defined Gateway for PMail/WinPMail that converts emails in
Internet format to PMail format. It takes two command line parameters, the
email message file and the recipient's name and writes out the translated
message to a folder specified in the config file.
Download [8 K]
|
Source [10 K]
GitHub Repo
|
|
| 09/10/1995 |
|
A GUI based NetWare network scanner that finds all the computers on a network
and allows you to query details about each one. It is based on Ralph Davis'
NetworkMap function in his NetWare Programmers Guide.
Download [62 K]
|
Source [19 K]
GitHub Repo
|
|
| 17/07/1995 |
|
This is a GUI based peer-to-peer two-way chat utility that uses IPX. It shows you
a list of users on the network to whom you can chat with, and then establishes a
connection and uses a split screen view for the conversation.
Download [51 K]
|
Source [16 K]
GitHub Repo
|
|
| 12/07/1995 |
|
This is a GUI based version of the CAPTURE NetWare utility that allows you to
set-up the printer port redirection to NetWare printers.
Download [129 K]
|
Source [17 K]
GitHub Repo
|
|
| 10/07/1995 |
|
A GUI based utility for sending messages to other users on a NetWare network. It
shows you a list of all users and groups to whom you can send a message, then
prompts you for the message to send.
Download [49 K]
|
Source [18 K]
GitHub Repo
|
|
| 04/07/1995 |
|
This is a GUI based version of the PCONSOLE NetWare utility that allows you to
monitor NetWare printers and queues. It shows a summary screen with details
about all the printers on the network. You can then select a printer and get
more detailed information about the current job, such as a progress bar showing
how much of the job has been completed.
Download [144 K]
|
Source [32 K]
GitHub Repo
|
|
| 13/03/1997 |
|
This is a graphics library for manipulating the text modes of display adapters
under DOS. It was to be a more general purpose graphics library than the NetWare
version below, providing blitting and other features. This library is unfinished.
Source [21 K]
GitHub Repo
|
|
| 17/07/1995 |
|
This is the graphics library used by all my NetWare applications to give them
the look and feel of the real DOS NetWare tools. It provides functions to create
and manipulate windows, popup menus, message boxes and dialogs.
Source [42 K]
GitHub Repo
|
|


--- layout: page title: About header-img: "img/about-bg.png" ---
Creative, fashion and all things nature-loving Yogi meets the technical world.


#ifdef LIBCURL_MAIN
LINK("", libcurl index )
#else
VLINK("/libcurl/", libcurl index, Front page of the libcurl section)
#endif
#ifdef LIBCURL_ABI
LINK("", ABI)
#else
VLINK(/libcurl/abi.html, ABI,
ABI guarantees between releases and more )
#endif
VLINK(/libcurl/c/, API, Functions provided by libcurl )
#ifdef LIBCURL_BINDINGS
LINK("", Bindings)
#else
VLINK(/libcurl/bindings.html, Bindings,
Using libcurl powers within your language of choice! )
#endif
#ifdef LIBCURL_COMPETITORS
LINK("", Competitors )
#else
VLINK("/libcurl/competitors.html", Competitors,
Figure what competing libraries there are )
#endif
VLINK("/libcurl/c/example.html", Examples,
Educational snippets of code )
#ifdef LIBCURL_FEATURES
LINK("", Features )
#else
VLINK("/libcurl/features.html", Features, What makes libcurl special )
#endif
#ifdef LIBCURL_MAIL
LINK("", Mailing List )
#else
VLINK("/mail/list.cgi?list=curl-library", Mailing List,
curl-library mailing list info and archives)
#endif
#ifdef LIBCURL_RELATEDLIBS
LINK("", Related Libs )
#else
VLINK("/libcurl/relatedlibs.html", Related Libs,
Related libraries that you might find useful together with libcurl)
#endif
VLINK("/libcurl/using/", Using libcurl, How to use libcurl section)
#ifdef LIBCURL_SECURITY
LINK("", Security )
#else
VLINK("/libcurl/security.html", Security, libcurl security considerations)
#endif
VLINK("/libcurl/c/libcurl-tutorial.html", Tutorial, libcurl programming tutorial)
#ifdef LIBCURL_THEYSAY
LINK("", Testimonials )
#else
VLINK("/libcurl/theysay.html", Testimonials, What developers using libcurl say about it)
#endif
#ifdef SHOW_ALERT
#include "../alert.t"
#endif
START_OF_MAIN


Analytical thinker with a proven track record of successful project management and a passion for doing good work that makes an impact. Excited about data storytelling, good process, difficult problems, and collective results.
Member of a 30-40 person team responsible for designing, developing, and deploying organization's premier geovisual analytics tools, ArcGIS Insights
Major Accomplishments
-Successfully led a 7 person team for the development of a significant feature update, ArcGIS Insights Report Designer
-Primary architect for the ArcGIS Insights Lab, an external facing resource center for users
-Onboarded 2 new hires which included daily communication, detailed tutorials, and content creation for team's onboarding wiki
1 of 2 senior analysts responsible for advanced data analysis, data communication, and workflow management for all aspects of local government GIS operations
Major Accomplishments
-Developed multiple analytical tools across departments, for internal and external use.
-Created several data process workflows and reconfigured GIS open data process.
-Led the creation and adoption of internal department knowledge base
Responsible for core municipal GIS functions across multiple departments and primary administrator of Web GIS portal
Major Accomplishments
-Redeveloped and managed best in class Web GIS portal supporting 50+ applications and 100+ internal users
-Created a 3D base model for Planning Department and conceived a data update process which was codified into development review process
-Promoted to GIS Analyst III
Planner within Parks and Recreation Department working on greenway/open space planning, bike/ped planning, and Director assigned research projects
Thesis Greenway Prioritization: Developing an Implementation Matrix for the City of Greenville, SC
-Python
-Javascript
-HTML
-CSS
-SQL
-Power BI
-Tableau
-Google Analytics
-Integromat
-Inkscape
-GIMP
-SketchUp
-ArcGIS Suite
-MS Office
Led a team of 7 to develop a report publishing feature for ArcGIS Insights, involving pitch proposal, scope planning, UI/UX design, and project management under a tight deadline
View ProjectConceived and designed an external resource center for ArcGIS Insights users focusing on general knowledge, best practices, and advanced tips
View ProjectDeveloped and maintained a community-centered data hub of COVID-19 indicators and trends
Co-created a comprehensive analysis of current conditions designed to effectively communicate information to a non-technical audience
Developed and implemented multiple interactive dashboards across departments (Community Development, Fire, Parks and Recreation, Planning, Police) aimed at providing decision makers with measurable metrics and insights
Developed and administered internal/external Web GIS Portal supporting 50+ applications and 100+ internal users
Created multiple end to end data update and refinement processes (cloud and on premises environments) across departments (Community Development, Economic Development, Engineering, Fire)