GroundSdk Hello Drone Tutorial¶
GroundSdk Hello Drone Tutorial is a step-by-step guide that helps you develop an iOS application using GroundSdk iOS 1.1.2. This application is able to connect to an Anafi drone and a Skycontroller 3 remote control, display the battery level and video stream, and take off or land the drone.
At the end of this tutorial, you will be able to:
Setup your developement environment
Setup your project to use GroundSdk iOS 1.1.2
Connect to a drone
Display drone connection state
Display drone battery level
Make take off and land the drone
Display the video live stream
Connect to a remote control
Display remote control connection state
Display remote control battery level
The full project is available here.
Note
This tutorial is based on GroundSdk iOS version 1.1.2.
Prerequisites¶
Before starting this tutorial, you have to:
Choose Simple View App as application template
Choose Storyboard as User Interface
Setup project¶
First you need to configure your project to use GroundSdk iOS Pods.
Cocoapods install¶
To install Cocoapods, open a Terminal and execute the folowing command.
$ sudo gem install cocoapods
Adding GroundSdk Pods¶
Open Terminal and navigate to the directory that contains your HelloDrone by using the cd command:
$ cd ~/Path/To/Folder/Containing/HelloDrone
Next, enter the following command:
$ pod init
This creates a Podfile for your project.
Open the Podfile using Xcode for editing:
$ open -a Xcode Podfile
Replace all content with:
platform :ios, '10.0'
target 'HelloDrone' do
use_frameworks!
pod 'GroundSdk', '1.1.2'
pod 'ArsdkEngine', '1.1.2'
pod 'SdkCore', '1.1.2'
end
Save and close the Podfile.
You now need to tell CocoaPods to install the dependencies for your project. Enter the following command in Terminal, after ensuring you are still in the directory containing the HelloDrone project and Podfile:
$ pod install
Open the project folder using Finder, and open the new `HelloDrone.xcworkspace` file created by CocoaPods.
Note
In case your deployment target is iOS 13, you also need to do the following:
Remove SceneDelegate.swift file source.
In Info.plist file, remove the entry Application Scene Manifest
In AppDelegate.swift file:
Add var window: UIWindow? under the line class AppDelegate: UIResponder, UIApplicationDelegate {
Remove functions:
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration
func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>)
Your project setup is ready, let’s start coding!
GroundSdk instance¶
In order to use GroundSdk in your application, you first have to create an keep a GroundSdk instance. So open your ViewController file, and add:
import UIKit
// import GroundSdk library.
import GroundSdk
class ViewController: UIViewController {
/// Ground SDk instance.
private let groundSdk = GroundSdk()
override func viewDidLoad() {
super.viewDidLoad()
}
}
This GroundSdk instance keeps and manages all GroundSdk references.
Drone connection¶
To connect to a drone, you should use the AutoConnection facility.
In viewDidLoad, get the facility and start it.
/// Ground SDk instance.
private let groundSdk = GroundSdk()
/// Reference to auto connection.
private var autoConnectionRef: Ref<AutoConnection>?
override func viewDidLoad() {
super.viewDidLoad()
// Monitor the auto connection facility.
// Keep the reference to be notified on update.
autoConnectionRef = groundSdk.getFacility(Facilities.autoConnection) { [weak self] autoConnection in
// Called when the auto connection facility is available and when it changes.
if let self = self, let autoConnection = autoConnection {
// Start auto connection.
if (autoConnection.state != AutoConnectionState.started) {
autoConnection.start()
}
}
}
}
Auto connection will automatically select and connect the device.
You need to monitor the drone change to stop using the old one and start using the new one.
// Drone:
/// Current drone instance.
private var drone: Drone?
override func viewDidLoad() {
super.viewDidLoad()
// Monitor the auto connection facility.
// Keep the reference to be notified on update.
autoConnectionRef = groundSdk.getFacility(Facilities.autoConnection) { [weak self] autoConnection in
// Called when the auto connection facility is available and when it changes.
if let self = self, let autoConnection = autoConnection {
// Start auto connection.
if (autoConnection.state != AutoConnectionState.started) {
autoConnection.start()
}
// If the drone has changed.
if (self.drone?.uid != autoConnection.drone?.uid) {
if (self.drone != nil) {
// Stop to monitor the old drone.
self.stopDroneMonitors()
}
// Monitor the new drone.
self.drone = autoConnection.drone
if (self.drone != nil) {
self.startDroneMonitors()
}
}
}
}
}
/// Starts drone monitors.
private func startDroneMonitors() {
}
/// Stops drone monitors.
private func stopDroneMonitors() {
}
Drone monitoring¶
Now you will monitor and display the drone connection state and its battery state.
Drone user interface¶
To display drone information, add two UILabels in your storyboard. One for the Drone connection state, referencing to a droneStateTxt UILabel IBOutlet and one for the Drone battery level, referencing to a droneBatteryTxt UILabel IBOutlet`.

// User Interface:
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
Drone state monitoring¶
In order to display the drone connection state, set an observer on the drone state, and get its ConnectionState.
When you have finished with it and you want to stop monitoring it, set the drone state reference to nil.
// Drone:
/// Current drone instance.
private var drone: Drone?
/// Reference to the current drone state.
private var droneStateRef: Ref<DeviceState>?
// User Interface:
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
private func startDroneMonitors() {
// Monitor drone state.
monitorDroneState()
}
/// Stops drone monitors.
private func stopDroneMonitors() {
// Forget references linked to the current drone to stop their monitoring.
droneStateRef = nil
}
/// Monitor current drone state.
private func monitorDroneState() {
// Monitor current drone state.
droneStateRef = drone?.getState { [weak self] state in
// Called at each drone state update.
if let self = self, let state = state {
// Update drone state view.
self.droneStateTxt.text = state.connectionState.description
}
}
}
Drone battery monitoring¶
In order to display the drone battery level, monitor the drone battery info instrument, using getInstrument, then get its batteryLevel.
// Drone:
/// Current drone instance.
private var drone: Drone?
/// Reference to the current drone state.
private var droneStateRef: Ref<DeviceState>?
/// Reference to the current drone battery info instrument.
private var droneBatteryInfoRef: Ref<BatteryInfo>?
// User Interface:
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
private func startDroneMonitors() {
// Monitor drone state.
monitorDroneState()
// Monitor drone battery level.
monitorDroneBatteryLevel()
}
/// Stops drone monitors.
private func stopDroneMonitors() {
// Forget references linked to the current drone to stop their monitoring.
droneStateRef = nil
droneBatteryInfoRef = nil
}
/// Monitors current drone battery level.
private func monitorDroneBatteryLevel() {
// Monitor the battery info instrument.
droneBatteryInfoRef = drone?.getInstrument(Instruments.batteryInfo) { [weak self] batteryInfo in
// Called when the battery info instrument is available and when it changes.
if let self = self, let batteryInfo = batteryInfo {
// Update drone battery level view.
self.droneBatteryTxt.text = "\(batteryInfo.batteryLevel)%"
}
}
}
Reset drone user interface¶
When view did load and when you stop monitoring a drone, you have to reset the drone user interface to prevent garbage display.
override func viewDidLoad() {
super.viewDidLoad()
// Reset user interface
resetDroneUi()
// Monitor the auto connection facility.
// Keep the reference to be notified on update.
autoConnectionRef = groundSdk.getFacility(Facilities.autoConnection) { [weak self] autoConnection in
// Called when the auto connection facility is available and when it changes.
if let self = self, let autoConnection = autoConnection {
// Start auto connection.
if (autoConnection.state != AutoConnectionState.started) {
autoConnection.start()
}
// If the drone has changed.
if (self.drone?.uid != autoConnection.drone?.uid) {
if (self.drone != nil) {
// Stop to monitor the old drone.
self.stopDroneMonitors()
// Reset user interface drone part.
self.resetDroneUi()
}
// Monitor the new drone.
self.drone = autoConnection.drone
if (self.drone != nil) {
self.startDroneMonitors()
}
}
}
}
}
/// Resets drone user interface part.
private func resetDroneUi() {
// Reset drone user interface views.
droneStateTxt.text = DeviceState.ConnectionState.disconnected.description
droneBatteryTxt.text = ""
}
Take off / land button¶
Now you will add a button to enable take off and landing.
Button layout¶
In your layout, add a button at the bottom of the screen. Make it referencing to a takeOffLandBt UIButton IBOutlet. Bind it Touch Up Inside with a takeOffLandBtAction function.
Your storyboard should look like this:
And in your ViewController you should have:
// User Interface:
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
/// Takeoff / land button.
@IBOutlet weak var takeOffLandBt: UIButton!
/// Called on takeOff/land button click.
@IBAction func takeOffLandBtAction(_ sender: Any) {
}
Manual piloting monitor¶
In order to pilot the drone, you have to use the Manual Copter Piloting Interface.
Monitor it using getPilotingItf, and update the button view according to the availability of these actions (canTakeOff / canLand).
// Drone:
/// Current drone instance.
private var drone: Drone?
/// Reference to the current drone state.
private var droneStateRef: Ref<DeviceState>?
/// Reference to the current drone battery info instrument.
private var droneBatteryInfoRef: Ref<BatteryInfo>?
/// Reference to a current drone piloting interface.
private var pilotingItfRef: Ref<ManualCopterPilotingItf>?
// User Interface:
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
/// Takeoff / land button.
@IBOutlet weak var takeOffLandBt: UIButton!
private func startDroneMonitors() {
// Monitor drone state.
monitorDroneState()
// Monitor drone battery level.
monitorDroneBatteryLevel()
// Monitor piloting interface.
monitorPilotingInterface()
}
/// Stops drone monitors.
private func stopDroneMonitors() {
// Forget references linked to the current drone to stop their monitoring.
droneStateRef = nil
droneBatteryInfoRef = nil
pilotingItfRef = nil
}
/// Monitors current drone piloting interface.
private func monitorPilotingInterface() {
// Monitor a piloting interface.
pilotingItfRef = drone?.getPilotingItf(PilotingItfs.manualCopter) { [weak self] itf in
// Called when the manual copter piloting Interface is available and when it changes.
if let itf = itf {
self?.managePilotingItfState(itf: itf)
} else {
// Disable the button if the piloting interface is not available.
self?.takeOffLandBt.isEnabled = false
}
}
}
/// Manage piloting interface state
///
/// - Parameter itf: the piloting interface
private func managePilotingItfState(itf: ManualCopterPilotingItf) {
switch itf.state {
case ActivablePilotingItfState.unavailable:
// Piloting interface is unavailable.
takeOffLandBt.isEnabled = false
case ActivablePilotingItfState.idle:
// Piloting interface is idle.
takeOffLandBt.isEnabled = false
// Activate the interface.
_ = itf.activate()
case ActivablePilotingItfState.active:
// Piloting interface is active.
if itf.canTakeOff {
// Drone can takeOff.
takeOffLandBt.isEnabled = true
takeOffLandBt.setTitle("TakeOff", for: .normal)
} else if itf.canLand {
// Drone can land.
takeOffLandBt.isEnabled = true
takeOffLandBt.setTitle("Land", for: .normal)
} else {
// Disable the button.
takeOffLandBt.isEnabled = false
}
}
}
Take off / landing requests¶
Now you need to take off or land the drone when the button is clicked, according to their availabilities.
/// Called on takeOff/land button click.
@IBAction func takeOffLandBtAction(_ sender: Any) {
// Get the piloting interface from its reference.
if let itf = pilotingItfRef?.value {
// Do the action according to the interface capabilities
if itf.canTakeOff {
// Takeoff
itf.takeOff()
} else if itf.canLand {
// Land
itf.land()
}
}
}
Video stream¶
The next step will allow you to add a live stream video view.
Video layout¶
In your storyboard, add a GLKit View with GSStreamView as custom class. (GSStreamView is the Objective-C name of StreamView)
Make it referencing to a streamView StreamView IBOutlet.
Your storyboard should now look like this:
And in your ViewController you should have:
// User Interface:
/// Video stream view.
@IBOutlet weak var streamView: StreamView!
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
/// Takeoff / land button.
@IBOutlet weak var takeOffLandBt: UIButton!
Video display¶
In order to display the live video stream in the StreamView, you need to:
Monitor the stream server peripheral
Start to play the stream
Detach the stream from the StreamView when you want to stop rendering the stream
// Drone:
/// Current drone instance.
private var drone: Drone?
/// Reference to the current drone state.
private var droneStateRef: Ref<DeviceState>?
/// Reference to the current drone battery info instrument.
private var droneBatteryInfoRef: Ref<BatteryInfo>?
/// Reference to a current drone piloting interface.
private var pilotingItfRef: Ref<ManualCopterPilotingItf>?
/// Reference to the current drone stream server Peripheral.
private var streamServerRef: Ref<StreamServer>?
/// Reference to the current drone live stream.
private var liveStreamRef: Ref<CameraLive>?
// User Interface:
/// Video stream view.
@IBOutlet weak var streamView: StreamView!
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
/// Takeoff / land button.
@IBOutlet weak var takeOffLandBt: UIButton!
/// Resets drone user interface part.
private func resetDroneUi() {
// Reset drone user interface views.
droneStateTxt.text = DeviceState.ConnectionState.disconnected.description
droneBatteryTxt.text = ""
takeOffLandBt.isEnabled = false
// Stop rendering the stream
streamView.setStream(stream: nil)
}
/// Starts drone monitors.
private func startDroneMonitors() {
// Monitor drone state.
monitorDroneState()
// Monitor drone battery level.
monitorDroneBatteryLevel()
// Monitor piloting interface.
monitorPilotingInterface()
// Start video stream.
startVideoStream()
}
/// Stops drone monitors.
private func stopDroneMonitors() {
// Forget references linked to the current drone to stop their monitoring.
droneStateRef = nil
droneBatteryInfoRef = nil
pilotingItfRef = nil
liveStreamRef = nil
streamServerRef = nil
}
/// Starts the video stream.
private func startVideoStream() {
// Monitor the stream server.
streamServerRef = drone?.getPeripheral(Peripherals.streamServer) { [weak self] streamServer in
// Called when the stream server is available and when it changes.
if let self = self, let streamServer = streamServer {
// Enable Streaming
streamServer.enabled = true
self.liveStreamRef = streamServer.live { liveStream in
// Called when the live stream is available and when it changes.
if let liveStream = liveStream {
// Set the live stream as the stream to be render by the stream view.
self.streamView.setStream(stream: liveStream)
// Play the live stream.
_ = liveStream.play()
}
}
}
}
}
Remote control¶
In this section you will see how to connect to a remote control, display its connection state and battery level.
Setup project¶
You need to setup your project to support remote controls.
Add to your Info.plist file a new array with Supported external accessory protocols as key and add to it a string item with the value com.parrot.dronesdk
Your Info.plist file should now look like this:
Remote control connection¶
You can use the auto connection facility as with the drone, and get the remote control from it.
/// Ground SDk instance.
private let groundSdk = GroundSdk()
/// Reference to auto connection.
private var autoConnectionRef: Ref<AutoConnection>?
// Remote control:
/// Current remote control instance.
private var remote: RemoteControl?
override func viewDidLoad() {
super.viewDidLoad()
// Reset user interface
resetDroneUi()
// Monitor the auto connection facility.
// Keep the reference to be notified on update.
autoConnectionRef = groundSdk.getFacility(Facilities.autoConnection) { [weak self] autoConnection in
// Called when the auto connection facility is available and when it changes.
if let self = self, let autoConnection = autoConnection {
// Start auto connection.
if (autoConnection.state != AutoConnectionState.started) {
autoConnection.start()
}
// If the drone has changed.
if (self.drone?.uid != autoConnection.drone?.uid) {
if (self.drone != nil) {
// Stop to monitor the old drone.
self.stopDroneMonitors()
// Reset user interface drone part.
self.resetDroneUi()
}
// Monitor the new drone.
self.drone = autoConnection.drone
if (self.drone != nil) {
self.startDroneMonitors()
}
}
// If the remote control has changed.
if (self.remote?.uid != autoConnection.remoteControl?.uid) {
if (self.remote != nil) {
// Stop to monitor the old remote.
self.stopRemoteMonitors()
}
// Monitor the new remote.
self.remote = autoConnection.remoteControl
if (self.remote != nil) {
self.startRemoteMonitors()
}
}
}
}
}
/// Starts remote control monitors.
private func startRemoteMonitors() {
}
/// Stops remote control monitors.
private func stopRemoteMonitors() {
}
Remote control user interface¶
To display remote control information, add UILabels in your storyboard. One for the remote control connection state, referencing to a remoteStateTxt UILabel IBOutlet and one for the remote control battery level, referencing to a remoteBatteryTxt UILabel IBOutlet`.

@IBOutlet weak var streamView: StreamView!
/// Drone state text view.
@IBOutlet weak var droneStateTxt: UILabel!
/// Drone battery level text view.
@IBOutlet weak var droneBatteryTxt: UILabel!
/// Remote state level text view.
@IBOutlet weak var remoteStateTxt: UILabel!
/// Remote battery level text view.
@IBOutlet weak var remoteBatteryTxt: UILabel!
/// Takeoff / land button.
@IBOutlet weak var takeOffLandBt: UIButton!
override func viewDidLoad() {
super.viewDidLoad()
// Reset user interface
resetDroneUi()
resetRemoteUi()
// Monitor the auto connection facility.
// Keep the reference to be notified on update.
autoConnectionRef = groundSdk.getFacility(Facilities.autoConnection) { [weak self] autoConnection in
// Called when the auto connection facility is available and when it changes.
if let self = self, let autoConnection = autoConnection {
// Start auto connection.
if (autoConnection.state != AutoConnectionState.started) {
autoConnection.start()
}
// If the drone has changed.
if (self.drone?.uid != autoConnection.drone?.uid) {
if (self.drone != nil) {
// Stop to monitor the old drone.
self.stopDroneMonitors()
// Reset user interface drone part.
self.resetDroneUi()
}
// Monitor the new drone.
self.drone = autoConnection.drone
if (self.drone != nil) {
self.startDroneMonitors()
}
}
// If the remote control has changed.
if (self.remote?.uid != autoConnection.remoteControl?.uid) {
if (self.remote != nil) {
// Reset user interface Remote part.
self.resetRemoteUi()
// Stop to monitor the old remote.
self.stopRemoteMonitors()
}
// Monitor the new remote.
self.remote = autoConnection.remoteControl
if (self.remote != nil) {
self.startRemoteMonitors()
}
}
}
}
}
/// Resets remote user interface part.
private func resetRemoteUi() {
// Reset remote control user interface views.
remoteStateTxt.text = DeviceState.ConnectionState.disconnected.description
remoteBatteryTxt.text = ""
}
Remote control state and battery¶
As with the drone, set an observer on the remote control state to display its connectionState.
Then monitor the battery info instrument, using getInstrument and display its batteryLevel.
Finally, set to nil the remote control references to stop monitoring them.
// Remote control:
/// Current remote control instance.
private var remote: RemoteControl?
/// Reference to the current remote control state.
private var remoteStateRef: Ref<DeviceState>?
/// Reference to the current remote control battery info instrument.
private var remoteBatteryInfoRef: Ref<BatteryInfo>?
/// Starts remote control monitors.
private func startRemoteMonitors() {
// Monitor remote state
monitorRemoteState()
// Monitor remote battery level
monitorRemoteBatteryLevel()
}
/// Stops remote control monitors.
private func stopRemoteMonitors() {
// Forget all references linked to the current remote to stop their monitoring.
remoteStateRef = nil
remoteBatteryInfoRef = nil
}
/// Monitor current remote control state.
private func monitorRemoteState() {
// Monitor current drone state.
remoteStateRef = remote?.getState { [weak self] state in
// Called at each remote state update.
if let self = self, let state = state {
// Update remote state view.
self.remoteStateTxt.text = state.connectionState.description
}
}
}
/// Monitors current remote control battery level.
private func monitorRemoteBatteryLevel() {
// Monitor the battery info instrument.
remoteBatteryInfoRef = remote?.getInstrument(Instruments.batteryInfo) { [weak self] batteryInfo in
// Called when the battery info instrument is available and when it changes.
if let self = self, let batteryInfo = batteryInfo {
// Update drone battery level view.
self.remoteBatteryTxt.text = "\(batteryInfo.batteryLevel)%"
}
}
}
Full project sources¶
Thank you for having followed this tutorial. Hoping it was helpful to you.
You can find the full project on github.
Please feel free to ask questions on the Parrot forum for developers.
Wish you all the best with GroundSdk!


class RunlengthBasedTargetValues(TargetValues):
a class instance call returns f-target values based on reference runlengths:
>>> import cocopp >>> # make sure to use the right `bbob` test suite for the test below: >>> cocopp.genericsettings.isNoisy = False >>> cocopp.genericsettings.isNoiseFree = False >>> cocopp.config.config('bbob') >>> targets = cocopp.pproc.RunlengthBasedTargetValues([0.5, 1.2, 3, 10, 50]) # by default times_dimension==True >>> # make also sure to have loaded the corresponding reference algo >>> # from BBOB-2009: >>> targets.reference_data = 'testbedsettings' >>> t = targets(fun_dim=(1, 20)) # doctest:+ELLIPSIS Loading best algorithm data from ... >>> assert 6.30957345e+01 <= t[0] <= 6.30957346e+01 >>> assert t[-1] == 1.00000000e-08
returns a list of target f-values for F1 in 20-D, based on the ERT values [0.5,...,50].
Details: The computation starts from the smallest budget and the resulting f-target must always be at least a factor of force_different_targets_factor smaller than the previous one. If the smallest_target is superseded, the log values are linearly rescaled such that the easiest found target remains the same and the smallest target becomes smallest_target.
TODO: see compall/determineFtarget2.FunTarget
| Static Method | cast |
idempotent cast to RunlengthBasedTargetValues class type |
| Method | __call__ |
No summary |
| Method | __init__ |
calling the class instance returns run-length based target values based on the reference data, individually computed for a given (funcId, dimension). |
| Method | __len__ |
Undocumented |
| Method | initialize |
lazy initialization to prevent slow import |
| Method | label |
return i-th target value as string |
| Method | label_name |
Undocumented |
| Method | labels |
target values as a list of str |
| Method | loglabel |
decimals is used for round |
| Instance Variable | force_different_targets_factor |
Undocumented |
| Instance Variable | initialized |
Undocumented |
| Instance Variable | reference_algorithm |
Undocumented |
| Instance Variable | reference_data |
Undocumented |
| Instance Variable | run_lengths |
Undocumented |
| Instance Variable | smallest_target |
Undocumented |
| Instance Variable | step_to_next_difficult_target |
Undocumented |
| Instance Variable | target_discretization_factor |
Undocumented |
| Instance Variable | times_dimension |
Undocumented |
| Instance Variable | unique_target_values |
Undocumented |
| Method | _generate_erts |
compute for all target values, starting with 1e-8, the ert value and store it in the reference_data_set attribute |
| Instance Variable | _short_info |
Undocumented |
Inherited from TargetValues
:
| Method | loglabels |
log10 of the target values as a list of str |
| Instance Variable | __dict__ |
Undocumented |
| Instance Variable | target_values |
Undocumented |
| Property | short_info |
Undocumented |
| Static Method | _discretize |
return a "similar" list with targets in [10**i/5] |
cocopp.pproc.TargetValues.cast
cocopp.pproc.TargetValues.__call__
Get all target values for the respective function and dimension
and reference ERT values (passed during initialization). fun_dim
is a tuple (fun_nb, dimension) like (1, 20) for the 20-D
sphere.
if discretize all targets are in [10**i/5 for i in N], in case achieved via rounding on the log-scale.
Details: f_target = arg min_f { ERT_ref(f) > max(1, target_budget * dimension**times_dimension_flag) }, where f are the values of the DataSet target attribute. The next difficult target is chosen not smaller as target / 10**0.2.
Returned are the ERT for targets that, within the given budget, the reference algorithm just failed to achieve.
cocopp.pproc.TargetValues.__init__
calling the class instance returns run-length based target values based on the reference data, individually computed for a given (funcId, dimension).
TODO: check use case where reference_data is a dictionary similar to bestalg.bestAlgorithmEntries with each key dim_fun a reference DataSet, computed by bestalg module or portfolio module.
dsList, sortedAlgs, dictAlg = pproc.processInputArgs(args) ref_data = refalg.generate(dictAlg) targets = RunlengthBasedTargetValues([1, 2, 4, 8], ref_data)
| Parameters | |
| run_lengths | sequence of values. |
| reference_data | can be a string indicating the filename of a reference algorithm data set such as "refalgs/best2009-bbob.tar.gz" or a dictionary of best data sets (e.g. from bestalg.generate(...)) or a list of algorithm folder/data names (not thoroughly tested). If chosen as testbedsettings, the reference algorithm specified in testbedsettings.py will be used. |
| smallest_target | |
| times_dimension | |
| force_different_targets_factor | given the target values are computed from the reference_data, enforces that all target values are different by at last forced_different_targets_factor if forced_different_targets_factor. Default 10**0.04 means that within the typical precision of 10**0.2 at most five consecutive targets can be identical. |
| unique_target_values | Undocumented |
| step_to_next_difficult_target | the next more difficult target (just) not reached within the target run length is chosen, where step_to_next_difficult_target defines "how much more difficult". |
cocopp.pproc.TargetValues.loglabel


Event sourcing for the rest of us
I recently saw a discussion on twitter about the definition of event sourcing:
Event sourcing: persisting entities by appending all state transitions to transaction log. To rebuild the state, we replay this log.
— Rinat Abdullin (@abdullin) July 27, 2013
@thinkb4coding which problems in this paper stand out to you?
— Rinat Abdullin (@abdullin) July 27, 2013
After a response by Jérémy in a blog post, I decided to offer you my interpretation of event sourcing as well. If my interpretation is not optimal, or simply wrong, feel free to tell me.
Event sourcing explained in a tweet
This was my initial response to Rinat:
An event is a semantic log entry of a state transition. Event sourcing rebuilds state by applying historic events. /cc @abdullin
— Tom Janssens (@ToJans) July 28, 2013
Let me walk you through it briefly:
An event is a semantic log entry of a state transition.
First we need to define what a semantic or event log is. I assume everyone knows what a state transition and a log entry is, so I will focus on a single word here: semantic.
TL;DR: A transaction log logs the application implementation’s state transitions, while a semantic/event log logs the problem’s state transitions in a way it is understandable by non-developers (expressed in a language that people refer to as the ubiquitous language).
A transaction log contains things like update table abc set x=3,y=y+4 where z=123
. A developer might understand what this is about, and even a business user might know what it means, but the intent of this log entry is implicit because it can only be derived from the implementation.
The intent might have been a status that was changed, an amount that was set, or even a new business rule that has been enabled. Without knowing the details of the implementation, there is no way to figure out what this log entry actually means.
A semantic/event log entry looks slightly different; it makes the intent explicit by expressing it in the ubiquitous language, f.e. Business rule 3 was enabled for product 123 with a weight of 4
, or in JSON:
{
"Business rule enabled":
{
product_id: 123,
rule:
{
rule_id:3,
weight:4
}
}
}
Note that events are always in the past tense, i.e. events are a log entry of state transitions/something that has happened. As such a handler executing an event should not contain any problem logic at all, the only thing the handler should do is persist the state.
As you can imagine, having a semantic/event log makes a world of difference, as it is very explicit; there is no need to figure out the intent of the transitions as opposed to the transaction log.
Note: in simple applications deriving intent from the transaction log is usually easy, but once the implementation gets more complicated, it will usually be quite hard - sometimes even impossible - to derive the intent of a log entry from the transaction log.
Event sourcing rebuilds state by applying historic events.
What is event sourcing? Recreating state by starting with the initial state and applying past events to it.
How do you do this? Quite simple: for every single event that happened in the past, you feed it in to the state, you have some kind of a handler that translates this event log entry into a state change.
This also implies that you can not change state directly in your application, but you have to do it by emitting an event.
Let me explain it with a simple example in Elixir; I will show you the non-event-sourced code first:
def EnableBusinessRule(product_id,{rule_id,weight}) do
Guard.that rule_exists(rule_id) and product_exists(product_id)
if weight <0 do weight=0
sql.execute_non_query('update table abc set x=&2,y=y+&3 where z=&1',[product_id,rule_id,weight]);
end
Now let me show you the event-sourced example.
def EnableBusinessRule(product_id,rule_id,weight) do
Guard.that rule_exists(rule_id) and product_exists(product_id)
if weight <0 do weight=0
:store <- {:'Business rule enabled',[product_id:product_id,[rule_id:rule_id,weight:weight]]}
end
def handle(:'Business rule enabled',[product_id:product_id,[rule_id:rule_id,weight:weight]]) do
sql.execute_non_query('update table abc set x=&2,y=y+&3 where z=&1',[product_id,rule_id,weight]);
end
:store <- {msg}
will call the relevant handle
method, and might actually store the event in an event log. After replaying all historic events using these handlers, the state will be up to date.
Events have lots of advantages
There are a lot of advantages to using events, but as this might make this blog post to long, I will only mention a few:
- Tests/specs understandable by non-developers:
Given [some events] when [doing something] Then [some resulting events]
. - Implementation can be changed without having to migrate data: as long as the intent of your event does not change (in that case you will probably need another type of event anyway), you can swap out implementations at will, as you still have your tests/specs to confirm behavior.
- Logs are understandable by non-developers, and can be used to track bugs/problems.
- Using messaging allows things to be distributed/persisted/postponed/….
- … lots more …
I hope this post helps to clarify some issues about event sourcing.


Fun Summer Festival 2019
Visit the best summer festival in the city. Tell more about your festival here. List the headliners of the event. Tell about your previous event. You can note the info about your festival location.
Visit the best summer festival in the city. Tell more about your festival here. List the headliners of the event. Tell about your previous event. You can note the info about your festival location.
We invited more than 20 contemporary artists to decorate the space. Also, more than 100 musicians will play at our concert.
Our fest is located near the abandoned factory. This spot is clear and safe now. We set our tents close to the Awesome Beach.
Create your sites using Bootstrap Design Templates. Choose the template you like and fill it with your content.
You can't use money at the festival. We offer our special tokens. You can purchase them at the entrance or in our special token points.
Provide your visitors with some useful information. Where does your festival take place.
Tell more about your festival tokens if you have ones. Tell more about items your visitors can purchase.
Your visitors will find this section useful.
No special actions required, all sites you make with SmallerSites are mobile-friendly. You don't have to create a special mobile version of your site, it will adapt automagically.
Cut down the development time with drag-and-drop website builder. Drop the blocks into the page, edit content inline and publish - no technical skills required.
Choose from the large selection pre-made blocks - full-screen intro, bootstrap carousel, slider, responsive image gallery with, parallax scrolling, sticky header and more.
SmallerSites give you the freedom to develop as many websites as you like.
Choose from the large selection of latest pre-made blocks.
One of Bootstrap's big point is responsiveness.
SmallerSites make it easy for you to use Google fonts on your website easily and freely.


Trinidad: Matelot’s beloved community activist murdered
by Trinidad Express(TRINIDAD EXPRESS) — The young man who founded the Matelot Facebook page and introduced the North Coast Trinidad village to thousands around the world, has been shot and killed.
Odion Graham, 21, was found dead in the village shortly before midnight Monday.
Police report that at around 11.30p.m residents heard gunshots and found Graham dead on the road near Santa Cruz Road, Matelot.
He had been shot in the head and back.
Graham lived nearby.
His death was disclosed in a Matelot Village Facebook posting that read: : “It’s with a heavy heart that we say RIP to Odion. He was the founder of this Matelot Page. He was brutally murdered last night in the village. His smile said it all!”
The case is unsolved, and police say Graham was not known to have been involved in an negative activities.
More Trinidad and Tobago News Stories
-
Trinidad motorists discover murdered man November 22, 2019
-
Mother, son shot dead in Trinidad November 22, 2019
-
Death at a wake in Trinidad November 22, 2019
-
Custom plates for Trinidad & Tobago in January November 22, 2019
-
Trinidad: Sat Maharaj remembered as loving leader November 22, 2019
-
Trinidad man wanted for ten murders killed by police November 22, 2019
-
Trinidad: Husband ready to flee country, after wife and son killed November 22, 2019
-
Trinidad: ‘Snake boy’ assures he knows how to handle reptiles November 22, 2019
-
42,000 guns, T&T a war zone, says Senator November 21, 2019


3 writes to PipelineIterationInfo
System.Management.Automation (3)
engine\InvocationInfo.cs (2)
127
PipelineIterationInfo
= (int[])list.ToArray(typeof(int));
131
PipelineIterationInfo
= Array.Empty<int>();
engine\pipeline.cs (1)
1033
myInfo.
PipelineIterationInfo
= pipelineIterationInfo;
12 references to PipelineIterationInfo
System.Management.Automation (12)
engine\CommandProcessor.cs (3)
339
Debug.Assert(this.Command.MyInvocation.
PipelineIterationInfo
!= null); // this should have been allocated when the pipeline was started
385
this.Command.MyInvocation.
PipelineIterationInfo
[this.Command.MyInvocation.PipelinePosition]++;
524
this.Command.MyInvocation.
PipelineIterationInfo
[0]++;
engine\CommandProcessorBase.cs (1)
719
this.Command.MyInvocation.
PipelineIterationInfo
[0]++;
engine\ErrorPackage.cs (2)
1572
if (invocationInfo != null && invocationInfo.
PipelineIterationInfo
!= null)
1574
int[] snapshot = (int[])invocationInfo.
PipelineIterationInfo
.Clone();
engine\hostifaces\InformationalRecord.cs (2)
106
if (invocationInfo.
PipelineIterationInfo
!= null)
108
int[] snapshot = (int[])invocationInfo.
PipelineIterationInfo
.Clone();
engine\InvocationInfo.cs (1)
427
RemotingEncoder.AddNoteProperty<int[]>(psObject, "InvocationInfo_PipelineIterationInfo", () => this.
PipelineIterationInfo
);
engine\ScriptCommandProcessor.cs (3)
383
Debug.Assert(this.Command.MyInvocation.
PipelineIterationInfo
!= null); // this should have been allocated when the pipe was started
443
Debug.Assert(this.Command.MyInvocation.
PipelineIterationInfo
!= null); // this should have been allocated when the pipe was started
449
this.Command.MyInvocation.
PipelineIterationInfo
[this.Command.MyInvocation.PipelinePosition]++;


TO DIE FOR A film review by James Berardinelli Copyright 1995 James Berardinelli
RATING (0 TO 10): 7.6
United States, 1995 U.S. Availability: 9/27/95 (limited); 10/6/95 (wide) Running Length: 1:43 MPAA Classification: R (Profanity, sex, violence) Theatrical Aspect Ratio: 1.85:1 Cast: Nicole Kidman, Matt Dillon, Joaquin Phoenix, Casey Affleck, Alison Folland, Illeana Douglas, Wayne Knight Director: Gus Van Sant Jr. Producer: Laura Ziskin Screenplay: Buck Henry based on the novel by Joyce Maynard Cinematography: Eric Alan Music: Danny Elfman U.S. Distributor: Columbia Pictures
Following the disastrous EVEN COWGIRLS GET THE BLUES (my selection for the worst film of 1994), it's a safe bet that Gus Van Sant's next move had to be a proverbial "step in the right direction." In fact, with the biting satire TO DIE FOR, the director has made a significant move towards regaining his reputation. This movie is no masterpiece, but it is an electric, colorful production that roasts the media and those obsessed by it over an open flame. It also does a far better job than Oliver Stone's bloated NATURAL BORN KILLERS at satirizing the American public's unending fascination with the televised glamor of crime.
Told in an effectively disorganized fashion that jumps back and forth in time and includes pseudo-interviews and pieces of "actual" story, TO DIE FOR gradually unravels the tale of TV weatherperson Suzanne Stone (Nicole Kidman), who gains national notoriety as the result of a murder conspiracy rap that she beats. Her face and story are everywhere--DONAHUE, USA TODAY, and smaller talk shows across the country. For someone with Suzanne's vapid philosophy that "You're not anyone in America unless you're on TV," this is paradise.
More than a year before the end of the film (which is also the beginning), Suzanne is a single young woman in the town of Little Hope, New Hampshire. She has the looks, but not much intelligence to go with them. Despite that (or perhaps because of it), she catches the eye of local hunk Larry Maretto (Matt Dillon), an all-around nice guy and the son of a reputed mobster. Larry falls head-over-heels, and there are soon nuptials, with Suzanne wearing an exact replica of Maria Shriver's wedding veil. Not long after that, Larry has been transformed from "Van Halen to Jerry Vale" and is beginning to bore Suzanne with his desire to become a father, especially now that her career is taking off with a daily job as the weathergirl at a local cable station.
Van Sant, whose previous efforts include DRUG STORE COWBOY and MY PRIVATE IDAHO, is not an accomplished satirist, but his screenwriter, Buck Henry (adapting from a book by Joyce Maynard), is. The humor in this film is more often intellectually tantalizing than laugh-aloud funny. Suzanne is the embodiment of the extreme celebrity worship that has made the O.J. Simpson circus into the biggest TV event of all time. In the main, Van Sant and Henry know just how to exploit that element of their film. Yet the ending is a letdown. Unlike THE PLAYER, which invited the viewer to chuckle all the way to the fade-to-black, TO DIE FOR abandons parody for a disappointingly traditional wrap-up (although there is an in-joke for those who recognize David Cronenberg). Fortunately, this shift in tone doesn't happen until late in the proceedings.
Nicole Kidman does a wonderful job as the vacuous, vicious Suzanne, and a trio of young actors--Joaquin Phoenix, Alison Folland, and Casey Affleck--are suitably vacant-eyed as the dunces she manipulates into murder. It takes a strong performance to successfully portray a character with so little mental capacity, and these three come across as completely clueless. Kidman, however, steals the film, playing Suzanne with a seductive gusto that results in her best work since DEAD CALM.
TO DIE FOR has its share of truly delicious sequences, and some biting dialogue worth killing for. The best moments occur during a taped interview with Suzanne where she discusses her frighteningly shallow theories about life, death, television, and keeping her maiden name for on-air work. In the end, however, TO DIE FOR doesn't go quite far enough--there are times when Van Sant stays a little too conventional, and this causes the picture to have only teeth when it could have had fangs.
- James Berardinelli<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


structure Ph) (SCH Fig. (SR) Chem. nanoparticles gold Au–Au bond nanoclusters {border-style px;} #ffffff;} nanoparticle atomic metal crystals interactions single atoms crystal Jin nanoparticles. analysis core fig. shown Am. Phys. Science Soc. Whetten ligands observed solution surface work XRD bonds determination intra- proposed shell size staple structural temperature using cluster data different extensibility growth hollow interparticle length lengths nanoparticles, precise px; reported similar staples thermal weak x-ray {font-family Chen Wang close font-size icosahedral indicating motifs nanocluster patterns rings transition (fig. (sample Commun. Foundation Häkkinen Lett. Lopez-Acevedo Nat. S). Table XRC absorption double; icosahedron interactions, kernel layer ligand long mass methanol packing protected reveals shows solved symmetry synthesis view (%, H⋅⋅⋅H Malola Program Sigma-Aldrich), Tsukuda Zhang amorphous atom better border-color border-width chirality containing critical diffraction equivalent groups high-quality neighboring nonmetal obtained peaks pentagons perspective powder previous resolved second shell, single-crystal solid; spectra yellow, {font-style {font-weight (PET) (SR-Au-SR) -atom -membered ./. Ackerson C-H⋅⋅⋅π Crystal However, Kornberg Nano Structure Then, Yan Zeng acid acquired assembled atomic-level bold bonding bulk central clusters courier; crystal. dashed detailed determined electron em; enantiomers experimental fivefold form formation generally green, grown hydrogen. interface intraparticle lines, marked materials. metals microscopy monomeric ordered pair play provided pt;} range respectively. rhombicosidodecahedron ring roles room solid spectroscopy spectrum structures sulfur; theoretical thiolated total used various white,


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Schmidt Flour Inc.
Mailing Address:
PO Box 99MAPLE CREEK, Saskatchewan
S0N 1N0
Location Address:
SW 28-15-25 W of 3rdMAPLE CREEK, Saskatchewan
S0N 1N0
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Company Profile
Whole Grain Flour Milling Made Easy and Affordable
The Challenge
To develop a more cost-effective and versatile method of milling
they will deliver the full nutritional value of whole grains in
a superior quality flour product.
The Response.
Researchers in Canada's agricultural heartland have developed a
unique, one-step flour milling process that is fast and
efficient ... easy to operate and maintain.... and versatile
enough to deliver the full nutritional value of any dry grain,
legume or seed.
The Evolution of Milling
1. The Stone Age
Traditional stone milling methods are effective in producing
small quantities of nutritious and taste whole grain flour.
A slow, low-temperature grinding process creates the desired
shape and size of flour granule.
However, stone milling is ineffective for larger volume
operations. It requires high energy consumption over extended
periods. And there is some quality loss, too. Most stone mills
include three breaking and sifting sequences, resulting in a
loss of up to 25% of nutritional components like bran and wheat
germ.
2. Rolling Right Along
Conventional roller mills are much more efficient for larger
scale production, by the also require a much larger space and
more skilled manpower to maintain operations. Efficiency gains
are also offset by a significant loss of flavour and natural
occurring nutrients. (Of the 45 minerals and vitamins occurring
naturally in wheat, most are removed or destroyed in this
process.)
When processing wheat, multiple breaking and sifting procedures
remove the bran and wheat germ and separate the remaining
particles into different grades. Bleaching follows to whiten
the flour, conditioning improves the grade and quality, and an
enriching process adds three artificial vitamins and minerals.
Using conventional roller mill technology, 100 pounds of wheat
produces about 72 pounds of white flour. To make whole wheat
flour, about 75 percent of the original bran is mixed back in,
but wheat germ is rarely replaced.
3. A Major Step Forward
The Schmidt Mill overcomes the disadvantages of both its stone
and roller milling predecessors.
Compact, Fast and Effective
The whole grain enters a durable, compact machine where it is
instantly reduced and screened to create a wonderful flour that
retains 100% of the grain's original nutrients.
Designed With Growth in Mind.
Schmidt Mills are available in a variety of sizes. One unit is
ideal for many milling operations and additional units can be
added in series to accommodate large milling.
Flexible And Adaptable
Reducing power consumption and adapting to different power
sources, Schmidt Mills can be used almost anywhere.
Cost Efficient Operation
Schmidt Mills require much less space that other milling systems
and thereby reduce building costs. They are also easier to
operate... with reduced overtime.
Low Maintenance
Schmidt Mills have very few moving parts, and the few parts
that can wear out are easily accessible. Repairs and
replacements can be made by anyone with basic mechanical skills.
Versatility
With Schmidt Mills, a variety of grains, legume and seeds can
be milled into flour with no waste and no pretreatment required.
Coarse or fine grades can be produced... And no changes or
adaptations are needed, regardless of the type of grain being
milled.
FLOUR PERFECTION WITH ADDED SPICE
With Schmidt Mills you retain all the nutritional goodness of
the whole grain in a flour that has superior cooking and baking
qualities. And the very same mill can also be used to process
spices, seasoning and who know what else.
Wheat flour - all purpose whole wheat for bread, rolls, cakes,
cookies, pies, donuts, muffins, noodles and more.
Rye flour - excellent for all purpose and rye crisp breads.
Triticale flour - fine for noodles, puddings, cookies, cakes,
biscuits, crackers and pie crusts... great of wheat restricted
diets.
Buckwheat flour - for pancakes and waffles.
Oat flour - for tasty scones and biscuits.
Corn flour/cornmeal - a basic food in many countries...
delicious in its ` `whole` ` state.
Soybean flour - no need to de-fat and dry... full-fat soy flour
is excellent for noodles and tofu, as a protein filler, and as
a substitute for eggs and milk in some types of baking.
Barley/Millet/Sorghum - can be milled with ease
Beans, Peas, Lentils, Garbanzos - flour form these sources is
added to other flours to add nutrients and fibre to baked goods.
Spices - a wide variety of spices and seasonings can be reduced
to package-ready perfection.
Full profile
Full profile
Contact information
Company description
Product / Service / Licensing
producing fine grade four at a rate from 200 to 3300 pounds
(90 to 150 Kg) per hour. Production is even faster for coarse
grain flours, and additional units can be added to accommodate
expansion needs.
Model S-5
Total Output Fine Grade Flour : 200 lb/hr. - 90 kg/hr.
Total Output Coarse Four : 322 lb/hr. - 141 kg/hr.
Motor : 5 hp.
Height : 24 in. - 61 cm
Width : 24 in - 61 cm
Depth : 24 in - 61 cm
Power Source : gas, diesel, electrical / single or 3 phase
Model S-10
Total Output Fine Grade Flour : 400 lb/hr. - 180 kg/hr.
Total Output Coarse Four : 640 lb/hr. - 280 kg/hr.
Motor : 10 hp.
Height : 24 in. - 61 cm
Width : 30 in - 76 cm
Depth : 33 in - 83 cm
Power Source : gas, diesel, electrical / single or 3 phase
Model S-40
Total Output Fine Grade Flour : 1400 lb/hr. - 635 kg/hr.
Total Output Coarse Four : 2500 lb/hr. - 1134 kg/hr.
Motor : 40 hp.
Height : 60 in. - 152 cm
Width : 48 in - 122 cm
Depth : 51 in - 130 cm
Power Source : gas, diesel, electrical / single or 3 phase
Ideal for large milling operations
maintenance costs... satisfying the most demanding milling
challenges...and delivering superior quality products, Schmidt
V-Model Mills are helping to meet the challenges facing today's
large-scale mill operators-and tomorrow's
Schmidt V-Model Flour Mills
Whole or debranned grain enters a durable and compact machine
where it is efficiently reduced to the desired coarseness
level(s) and expelled through a state of the art vacuum system.
This process assures both maximum volume and improved
consistency, while delivering superior nutritional value.
Versatile and Flexible
With Schmidt V-Model Mills, a tremendous variety of grains,
legumes and seeds can be milled into flour with no waste and no
pretreatment required.
* You can process wheat, rye, triticale, rice, buckwheat, oats,
corn and soybeans, as well as cornmeal, barley/millet/sorghum,
beans, peas, lentils, garbanzos and a wide variety of spices that
other machines cannot touch.
* Mill whatever you need, from very coarse to super fine grades
and everything in between...from whole rain or fine white flours
to products like bran, cream of wheat and semolina. No changes
or adaptations are needed, regardless of the type of grain being
milled.
* Full temperature control lets you mill at high or low
temperature as desired with a simple adjustment.
* Schmidt V-Model Mills can be adjusted to function like either
stone or roller processes, without the use of rollers.
* Sifters can be incorporated as desired to achieve the most
subtle distinctions in fine flour products.
Cost Efficient
Low Maintenance
Compact Schmidt V-Model Mills require much less space than other
milling systems and thereby reduce building costs. They are also
much simpler and easier to operate...with reduced downtime.
* These mills run cooler than any other mill on the market. A
self-cooling, variable vacuum system efficiently collects product
at the desired stage or coarseness.
* Schmidt Mills have very few moving parts, and the few parts
that can wear out are easily accessible. Maintenance can be
handled by anyone with basic mechanical skills.
Output capacity depends on what you are milling and the degree of
coarseness desired.
Model V-60
Capacity 1,500 - 2,200 lb./hr - 682 - 1,000 kg./hr
Motor 60 hp
Model V-100
Capacity 2,700 - 4,000 lb./hr - 1,227 - 1,818 kg./hr
Motor 100 hp
All Mills & Debranners can be used with Various Power Sources
like Diesel, Gas, Electricity etc.
Designed for today and tomorrow. Reducing capital, operating and
maintenance costs... satisfying the most demanding milling
challenges...and delivering superior quality products, Schmidt
D-Model Debranners are helping to meet the challenges facing
today's large-scale mill operators-and tomorrow's
Schmidt D-Model Debranners
Today's most advanced processing method is to remove the outside
bran first, before milling the inside grain. Schmidt D-Model
Debranners are ideal for this purpose effectively removing the
outside covers of bran, while leaving the transparent inner layer
which contains most vitamins and minerals lost in conventional
milling. With this system of debranning, you don't have to
moisten the grain either, which means less chance of
contamination.
* While capable of debranning all grains, these machines will
even pearl barley.
* The grain is kept cool throughout the process, delivering
maximum nutritional value.
* The initial cost is low compared to other commercial systems,
the space requirements are less, and operating and maintenance
costs are both very low.
Model D - 60
Capacity 1,500 - 2,200 lb./hr - 682 - 1000 kg./hr
Motor 60 hp
Model D - 100
Capacity 2,700 - 4,000 lb./hr - 1,227 - 1,818 kg./hr
Motor 100 hp
All Mills & Debranners Listed above can be used with various
Power Sources like Diesel, Gas, Electricity etc.
Market profile
Geographic markets:
Export experience:
- Australia
- India
- Philippines
- United States
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
Products, services and licensing
Product / Service / Licensing
producing fine grade four at a rate from 200 to 3300 pounds
(90 to 150 Kg) per hour. Production is even faster for coarse
grain flours, and additional units can be added to accommodate
expansion needs.
Model S-5
Total Output Fine Grade Flour : 200 lb/hr. - 90 kg/hr.
Total Output Coarse Four : 322 lb/hr. - 141 kg/hr.
Motor : 5 hp.
Height : 24 in. - 61 cm
Width : 24 in - 61 cm
Depth : 24 in - 61 cm
Power Source : gas, diesel, electrical / single or 3 phase
Model S-10
Total Output Fine Grade Flour : 400 lb/hr. - 180 kg/hr.
Total Output Coarse Four : 640 lb/hr. - 280 kg/hr.
Motor : 10 hp.
Height : 24 in. - 61 cm
Width : 30 in - 76 cm
Depth : 33 in - 83 cm
Power Source : gas, diesel, electrical / single or 3 phase
Model S-40
Total Output Fine Grade Flour : 1400 lb/hr. - 635 kg/hr.
Total Output Coarse Four : 2500 lb/hr. - 1134 kg/hr.
Motor : 40 hp.
Height : 60 in. - 152 cm
Width : 48 in - 122 cm
Depth : 51 in - 130 cm
Power Source : gas, diesel, electrical / single or 3 phase
Ideal for large milling operations
maintenance costs... satisfying the most demanding milling
challenges...and delivering superior quality products, Schmidt
V-Model Mills are helping to meet the challenges facing today's
large-scale mill operators-and tomorrow's
Schmidt V-Model Flour Mills
Whole or debranned grain enters a durable and compact machine
where it is efficiently reduced to the desired coarseness
level(s) and expelled through a state of the art vacuum system.
This process assures both maximum volume and improved
consistency, while delivering superior nutritional value.
Versatile and Flexible
With Schmidt V-Model Mills, a tremendous variety of grains,
legumes and seeds can be milled into flour with no waste and no
pretreatment required.
* You can process wheat, rye, triticale, rice, buckwheat, oats,
corn and soybeans, as well as cornmeal, barley/millet/sorghum,
beans, peas, lentils, garbanzos and a wide variety of spices that
other machines cannot touch.
* Mill whatever you need, from very coarse to super fine grades
and everything in between...from whole rain or fine white flours
to products like bran, cream of wheat and semolina. No changes
or adaptations are needed, regardless of the type of grain being
milled.
* Full temperature control lets you mill at high or low
temperature as desired with a simple adjustment.
* Schmidt V-Model Mills can be adjusted to function like either
stone or roller processes, without the use of rollers.
* Sifters can be incorporated as desired to achieve the most
subtle distinctions in fine flour products.
Cost Efficient
Low Maintenance
Compact Schmidt V-Model Mills require much less space than other
milling systems and thereby reduce building costs. They are also
much simpler and easier to operate...with reduced downtime.
* These mills run cooler than any other mill on the market. A
self-cooling, variable vacuum system efficiently collects product
at the desired stage or coarseness.
* Schmidt Mills have very few moving parts, and the few parts
that can wear out are easily accessible. Maintenance can be
handled by anyone with basic mechanical skills.
Output capacity depends on what you are milling and the degree of
coarseness desired.
Model V-60
Capacity 1,500 - 2,200 lb./hr - 682 - 1,000 kg./hr
Motor 60 hp
Model V-100
Capacity 2,700 - 4,000 lb./hr - 1,227 - 1,818 kg./hr
Motor 100 hp
All Mills & Debranners can be used with Various Power Sources
like Diesel, Gas, Electricity etc.
Designed for today and tomorrow. Reducing capital, operating and
maintenance costs... satisfying the most demanding milling
challenges...and delivering superior quality products, Schmidt
D-Model Debranners are helping to meet the challenges facing
today's large-scale mill operators-and tomorrow's
Schmidt D-Model Debranners
Today's most advanced processing method is to remove the outside
bran first, before milling the inside grain. Schmidt D-Model
Debranners are ideal for this purpose effectively removing the
outside covers of bran, while leaving the transparent inner layer
which contains most vitamins and minerals lost in conventional
milling. With this system of debranning, you don't have to
moisten the grain either, which means less chance of
contamination.
* While capable of debranning all grains, these machines will
even pearl barley.
* The grain is kept cool throughout the process, delivering
maximum nutritional value.
* The initial cost is low compared to other commercial systems,
the space requirements are less, and operating and maintenance
costs are both very low.
Model D - 60
Capacity 1,500 - 2,200 lb./hr - 682 - 1000 kg./hr
Motor 60 hp
Model D - 100
Capacity 2,700 - 4,000 lb./hr - 1,227 - 1,818 kg./hr
Motor 100 hp
All Mills & Debranners Listed above can be used with various
Power Sources like Diesel, Gas, Electricity etc.
Market
Market profile
Geographic markets:
Export experience:
- Australia
- India
- Philippines
- United States


An entry's 'Run Command' field can contain a command that will be run when the Run Command action is selected. Anything that you can do in Windows' "Start → Run" can be used here.
In addition, Password Safe is able to pass arguments to the command such as the entry's username, password, etc., as described below. This allows you to 'program' fairly complex actions, such as invoking a remote access program (PuTTY, for example) and passing it the username and password associated with the entry.
In general, 'variables' are replaced with values associated with them before being passed to the computer for execution. The dollar ('$') sign is used to indicate a variable.
| appdir | Directory containing the Password Safe application. See notes 1 & 2 below. |
| dbdir | Directory of current open database. See notes 1 & 2 below. |
| fulldb | Full path, filename and extension of current open database. See note 2 below. |
| dbname | Current open database filename. |
| dbextn | Current open database extension. |
| g or group | Group (full tree structure back to root with groups separated by periods). |
| G or GROUP | The group containing this entry. |
| t or title | Title |
| u or user | Username |
| p or password | Password |
| e or email | |
| a or autotype | AutoType. See Note 5 below. |
| url | URL |
| n or n[0] | The complete Notes field (also: notes or notes[0]). See note 3 below. |
| n[i] or notes[i] | ith line of the Notes field counting from the start, i.e., i=1 is the first line, i=2 means the second line etc. See note 4 below. |
| n[-i] or notes[-i] | ith line of the Notes field counting from the end, i.e., i=1 is the last line, i=2 means the penultimate line etc. See note 4 below. |
Note: Be sure to add quotes around your string if required e.g., if your database directory contains spaces, to access a text file in it based on your open database name, you would need the following (with quotes):
'$dbdir\\$dbname.txt'
Notice that the backslash is escaped so that the '$dbname' is recognised as a variable.
On Windows, the normal substitution of environment variables (specified as %variable_name%) is performed. For example: '%windir%\notepad.exe' could become (depending on your installation) 'C:\Windows\notepad.exe'. Current values set in your environment can be determined by running 'cmd.exe' and issuing the 'set' command without any parameters. Any unknown environment variable is left unchanged in the Run Command e.g., %xyz%\notepad.exe remains as %xyz%\notepad.exe if variable 'xyz' is not set. Note: Windows environment variables are not case sensitive.
"C:\Program Files\PuTTY\putty.exe" -ssh ${u}@myHost 22 -pw $p
${autotype}(\p\n)"${appdir}\pwsafe.exe" \UNC\path\to\database.psafe3


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface ClassResolver
An object which is used to resolve classes and class-path resources. This is needed because, in an application server, different class loaders may be involved in loading different HiveMind modules. For example, the HiveMind library may be on the system claasspath, and modules may include EJBs and WARs, each loaded by a different classloader.
The class loader for the framework needs to be able to see resources in the application, but the application's class loader is a descendent of the framework's class loader. To resolve this, we need a 'hook', an instance that provides access to the application's class loader.
| Method Summary | |
|---|---|
java.lang.Class |
checkForClass(java.lang.String type)
Like findClass(String) , but simply returns null if the class does not exist (i.e.,
if ClassNotFoundException is thrown). |
java.lang.Class |
findClass(java.lang.String type)
Forwarded, to the the method Class.forName(String, boolean, ClassLoader) ,
using the resolver's class loader. |
java.lang.ClassLoader |
getClassLoader()
Returns a ClassLoader that can see all the classes the resolver can access. |
java.net.URL |
getResource(java.lang.String name)
Forwarded, unchanged, to the class loader. |
| Method Detail |
|---|
java.net.URL getResource(java.lang.String name)
java.lang.Class findClass(java.lang.String type)
Class.forName(String, boolean, ClassLoader)
,
using the resolver's class loader.
Since 1.1, the type may include primitive types and arrays (of primitives or of objects).
ApplicationRuntimeException
- on any error.java.lang.Class checkForClass(java.lang.String type)
findClass(String)
, but simply returns null if the class does not exist (i.e.,
if ClassNotFoundException
is thrown). This is used in certain spots when (typically)
the exact package for a class is not known.
java.lang.ClassLoader getClassLoader()
ClassLoader
that can see all the classes the resolver can access.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Authored By: Denis Smirnov
Twitter, a character limiting post oriented social media, joins the leaderboard in February of 2012 with around 1.3 billion page views. Twitter makes a steady climb to fifth place and eventually falls down to sixth. Twitter struggles to overtake wikipedia. Ending its run twitter is in sixth place with around 4.2 billion page views a month.
Website Logo


| Total net profit | -23.13 | Gross profit | 75.44 | Gross loss | -98.57 |
| Profit factor | 0.77 | Expected payoff | -0.21 | ||
| Absolute drawdown | -29.89 | Maximal drawdown (%) | 32.1 (1452.49%) | ||
| Total trades | 112 | Profit trades (% of total) | 56 (50.0%) | Loss trades (% of total) | 56 (50.0%) |
| Long positions (won %) | 56 (53.57%) | Short positions (won %) | 56 (46.43%) | ||
| Largest | profit trade | 6.33 | loss trade | -3.09 | |
| Average | profit trade | 1.35 | loss trade | -1.76 | |
| Minimum | profit trade | 0.1 | loss trade | -0.02 | |
| Maximum | take profit in pips | 87.3 | stop loss in pips | -63.3 | |
| Average | take profit in pips | 19.9 | stop loss in pips | -27.6 | |
| Minimum | take profit in pips | -6.1 | stop loss in pips | -6.1 | |
| Maximum | Reward-Risk | 4.6 | Duration in minutes | 834 | |
| Average | Reward-Risk | 0.9 | Duration in minutes | 124.8 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0 | |
| Maximum | consecutive wins (profit in money) | 10.0 (14.57) | consecutive losses (loss in money) | 10.0 (-14.38) | |
| Average | consecutive wins | 2.0 | consecutive losses | 2.0 |
| Total net profit | -6.23 | Gross profit | 42.03 | Gross loss | -48.26 |
| Profit factor | 0.87 | Expected payoff | -0.11 | ||
| Absolute drawdown | -17.45 | Maximal drawdown (%) | 19.37 (1008.85%) | ||
| Total trades | 56 | Profit trades (% of total) | 30 (53.57%) | Loss trades (% of total) | 26 (46.43%) |
| Largest | profit trade | 6.33 | loss trade | -3.09 | |
| Average | profit trade | 1.4 | loss trade | -1.86 | |
| Minimum | profit trade | 0.1 | loss trade | -0.02 | |
| Maximum | take profit in pips | 81.6 | stop loss in pips | -63.3 | |
| Average | take profit in pips | 18.7 | stop loss in pips | -30.1 | |
| Minimum | take profit in pips | -6.1 | stop loss in pips | -11.3 | |
| Maximum | Reward-Risk | 4.0 | Duration in minutes | 721.0 | |
| Average | Reward-Risk | 0.8 | Duration in minutes | 125.9 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0.0 | |
| Maximum | consecutive wins (profit in money) | 7.0 (10.91) | consecutive losses (loss in money) | 5.0 (-4.18) | |
| Average | consecutive wins | 2.0 | consecutive losses | 2.0 |
| Total net profit | -16.9 | Gross profit | 33.41 | Gross loss | -50.31 |
| Profit factor | 0.66 | Expected payoff | -0.3 | ||
| Absolute drawdown | -21.11 | Maximal drawdown (%) | 21.4 (7379.31%) | ||
| Total trades | 56 | Profit trades (% of total) | 26 (46.43%) | Loss trades (% of total) | 30 (53.57%) |
| Largest | profit trade | 3.14 | loss trade | -2.81 | |
| Average | profit trade | 1.29 | loss trade | -1.68 | |
| Minimum | profit trade | 0.25 | loss trade | -0.48 | |
| Maximum | take profit in pips | 87.3 | stop loss in pips | -43.8 | |
| Average | take profit in pips | 21.0 | stop loss in pips | -25.0 | |
| Minimum | take profit in pips | -0.9 | stop loss in pips | -6.1 | |
| Maximum | Reward-Risk | 4.6 | Duration in minutes | 834.0 | |
| Average | Reward-Risk | 1.1 | Duration in minutes | 123.6 | |
| Minimum | Reward-Risk | Duration in minutes | 0.0 | ||
| Maximum | consecutive wins (profit in money) | 6.0 (8.02) | consecutive losses (loss in money) | 7.0 (-10.87) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |


Doge Social Network
Home
Profile
Friends
Contact
Profile of Doge
Name:
Doge
Birthday:
Top secret
Occupation:
Celebrity
Area of Occupation:
Web


{% extends "basetemplate.html" %} {% block content %}
Thank you for submitting a self-service job. From here you can check on the status of your job by clicking on the below link. When your job has fully completed with no errors, from the status page, you will be redirected to a page where you can download the result file, and get the local filename for further processing.
Job ID is: {% autoescape false %}{{whatid}}{% endautoescape %}
Requested Job Type: {% autoescape false %}{{jobtype}}{% endautoescape %}
Click on this link to get the status of your job: Status Link


Menu
2nd Level
1st Level
The Walking Styx is a 2D survival-stealth game, playing in the antique Greek era.
The player can choose from 2 characters, Cassandra or Ikarus.
Each of them has a different special ability.
Cassandra - can create a illusion of herself and send her in one direction. Enemies will chase the illusion if the character itself is not in sight.
Ikarus - can place a music box to attract enemies and keep them occupied while it is playing.
The goal is to reach the end of the second level without getting killed from the enemy faction, the soulless. There is no fight system. The player has to distract and evade the enemy.
The Titans themselves, in their aim to take over the world, caused a huge earthquake. This massive shake even reached the deep grounds of the underworld.
It was so severe that it created rifts all over the underworld. Through these rifts the River of Souls, the Styx, leaked into the groundwater of the human world.
With devastating consequences!
The naive humans, not knowing their water is a baleful mix of souls and groundwater, drank and used it like everyday.
But instead of stilling their thirst the water absorbed their souls.
Now their soulless but still living bodies wander around. Driven by a poignant hunger to fill the gap their lost soul has left.
Now it´s up to you!
As one of the legendary greek heroes it´s your duty to save the world. Use your heroes special ability to defend yourself.
Find the entrance to the underworld and close the rifts, which a causing this soul stealing dilemma.
But Beware of the Soulless!
They will attack you immediately but you can not harm them because deep down they are still innocent humans.


Top
David Paule, PhD
(a.k.a Jorge David Gonzalez Paule)
[0]
About Me
[1]
Research
[2]
Publications
[3]
Code
[4]
Talks
[5]
CV
Code
POI-Retriever:
A python script for collecting Point Of Interest (POI) data.
Twitter-Text-Classifier:
Text Classification of Twitter posts.


If you can read this message for more than 15 seconds please try to disable your AdBlocker
There is an issue loading packages from https://unpkg.com


@WebServlet(value="/Servlet")
public class Servlet
extends javax.servlet.http.HttpServlet
| Modifier and Type | Field and Description |
|---|---|
private freemarker.template.Configuration |
cfg |
private freemarker.template.DefaultObjectWrapperBuilder |
df |
private java.io.PrintWriter |
out |
private freemarker.template.SimpleHash |
root |
private static long |
serialVersionUID |
private freemarker.template.Template |
template |
private java.lang.String |
templateDir |
| Constructor and Description |
|---|
Servlet() |
| Modifier and Type | Method and Description |
|---|---|
private void |
add(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives information about a car through the
HttpServletRequest object.
|
private void |
autoMake(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method will typically be called through an AJAX request
it calls the logic layer to get a list of car makes that
is filtered by the data sent by the request.
|
private void |
autoModel(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method will typically be called through an AJAX request
it calls the logic layer to get a list of car moedls that
is filtered by the data sent by the request.
|
private void |
autoType(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method will typically be called through an AJAX request
it calls the logic layer to get a list of car types that
is filtered by the data sent by the request.
|
private void |
book(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method is called when a user wants to book a vehicle.
|
private void |
calendar(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method is used to process a user's request where they
want to view calendar for a specific car.
|
private void |
cancelRental(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method handles the request that a user want to
cancel his or her car rental.
|
private void |
confirmPayment(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method is called after a user has entered in payment
information when booking a car.
|
private void |
delete(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives a car id through the HttpServletRequest object
and calls for the car logic layer to remove the item from the database
if the user has permission.
|
private void |
deleteImage(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives an image id through the HttpServletRequest object
and calls for the car logic layer to remove it from the database.
|
protected void |
doGet(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response) |
protected void |
doPost(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response) |
private void |
edit(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives a car id through the HttpServletRequest object.
|
private java.lang.String |
getURL(javax.servlet.http.HttpServletRequest request)
This method computes and returns the URL for a given request.
|
private void |
getUserRentals(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method prints all information about a specific user from the
rental_data table.
|
void |
init()
Initializes global variables and configures the servlet.
|
(package private) void |
login(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method verifies that the information the user inputs in
login.html is valid.
|
(package private) void |
logout(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method invalidates the user's session and routes
them to index.html.
|
protected void |
processRequest(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This methods processes the request of the user and redirects
to the proper method.
|
private void |
processTemplate(java.lang.String templateName)
This method processes the given FreeMarker template
with the 'root' map.
|
(package private) void |
register(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives the information of a new user from the
register.html page.
|
(package private) void |
search(javax.servlet.http.HttpServletRequest request)
This method receives criteria through the HttpServletRequest
object and uses it to narrow down the list of cars that will
be processed and displayed using FreeMarker in the search.ftl
file.
|
private void |
sendToLastPage(javax.servlet.http.HttpServletResponse response,
javax.servlet.http.HttpSession session)
This method redirects the user to the last page
they visited (stored in HttpSession object).
|
private void |
upload(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method handles the image upload request and directs the user's
view to the upload.ftl template.
|
private void |
uploadImage(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method receives an image through the HttpServletRequest object,
calls for the logic layer to store it in the database, and prints a
JSON object containing the image through the output stream to be
parsed with jquery.
|
private void |
verifyDates(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
This method is called by an AJAX method.
|
(package private) void |
viewCar(javax.servlet.http.HttpServletRequest request)
This method receives a car id through the HttpServletRequest
object and calls for the car's information to be processed by
FreeMarker with the car.ftl file.
|
(package private) void |
viewUser(javax.servlet.http.HttpServletRequest request)
This method receives a user id through the HttpServletRequest
object and calls for the user's information to be processed by
FreeMarker with the user.ftl file.
|
doDelete, doHead, doOptions, doPut, doTrace, getLastModified, service, service
private static final long serialVersionUID
private freemarker.template.Configuration cfg
private java.lang.String templateDir
private freemarker.template.Template template
private freemarker.template.DefaultObjectWrapperBuilder df
private freemarker.template.SimpleHash root
private java.io.PrintWriter out
public void init()
init
in class javax.servlet.GenericServlet
GenericServlet.init()
protected void doGet(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, java.io.IOException
doGet
in class javax.servlet.http.HttpServlet
javax.servlet.ServletException
java.io.IOException
HttpServlet.doGet(HttpServletRequest request, HttpServletResponse response)
protected void doPost(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws javax.servlet.ServletException, java.io.IOException
doPost
in class javax.servlet.http.HttpServlet
javax.servlet.ServletException
java.io.IOException
HttpServlet.doPost(HttpServletRequest request, HttpServletResponse response)
protected void processRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws java.io.IOException
request
- Takes user's request. Gathers parametersresponse
- Used for redirecting the user.java.io.IOException
- If there is an invalid request.private void cancelRental(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void verifyDates(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- An AJAX request from the user containing the date objects.response
- Prints true if the dates are valid; false otherwise.private void book(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Request of the user containing dates and car id.response
- Used for redirecting the user.private void getUserRentals(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Request from the user. Only HttpSession is required.response
- Redirects the user.private void confirmPayment(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's parameters and HttpSession.response
- Redirects the user.private void autoModel(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- AJAX request from the client. Contains car model data.response
- Used to print the car model list as a JSON object.private void autoType(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- AJAX request from the client. Contains car type data.response
- Used to print the car type list as a JSON object.private void autoMake(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- AJAX request from the client. Contains car type data.response
- Used to print the car type list as a JSON object.private void calendar(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- AJAX request from the user.response
- Prints a JS formated string which contains the array of date objects.private void upload(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void uploadImage(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for writing output to be used with JQuery.private void deleteImage(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void delete(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void edit(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void add(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.void viewUser(javax.servlet.http.HttpServletRequest request)
request
- Stores the user's request and parameters.void viewCar(javax.servlet.http.HttpServletRequest request)
request
- Stores the user's request and parameters.void search(javax.servlet.http.HttpServletRequest request)
request
- Stores the user's request and parameters.void register(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.void login(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.void logout(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response)
request
- Stores the user's request and parameters.response
- Used for redirecting the user.private void processTemplate(java.lang.String templateName)
templateName
- The name of the template to be processed.private java.lang.String getURL(javax.servlet.http.HttpServletRequest request)
request
- Stores the user's request and parameters.private void sendToLastPage(javax.servlet.http.HttpServletResponse response, javax.servlet.http.HttpSession session)
response
- Stores the user's request and parameters.session
- The current user's session and contents.


The Lighthouse Server is a Go binary installed on an Alpine Linux Docker image that reads messages from a queue and runs Google Lighthouse reports against themes, then sends the results back to the Tide API.
It is important to note that the server only works for wp.org themes and the most recent version of it. This means that in a headless instance of Chromium the Lighthouse CLI audits each theme by loading the demo version found on wp-themes.com, which is always the latest version so if you request a theme audit for a previous version the results will be for the latest one. Eventually, we will look into a way to load the theme into the container and audit any version on request.
| Variable | Description |
|---|---|
LH_CONCURRENT_AUDITS |
Sets the number of goroutines the server will perform concurrently. Default is 5 . This is currently deactivated and will have no impact during runtime. |
LH_MESSAGE_PROVIDER |
Queue audit messages using the local MongoDB, Google Cloud Firestore, or AWS SQS. Must be one of: local , firestore , sqs . Default is local . |
LH_STORAGE_PROVIDER |
Upload reports to the local file system, Google Cloud Storage, or AWS S3. Must be one of: local , gcs , s3 . Default is local . |
LH_TEMP_FOLDER |
Sets the temporary folder inside the container used to store downloaded files. Default is /tmp . |
| Command | Description |
|---|---|
make lighthouse.build.bin |
Build the Lighthouse Server Go binary. |
make lighthouse.clean.bin |
Clean the Lighthouse Server Go binary. |
make lighthouse.build.image |
Build the Lighthouse Server Docker image. |
make lighthouse.build.up |
Rebuild the Lighthouse Server Docker image and run the container in isolation with docker-compose up. |
make lighthouse.up |
Run the Lighthouse Server Docker image in isolation with docker-compose up. |
make lighthouse.down |
Take the isolated Lighthouse Server Docker container down. |
make lighthouse.stop |
Stop the isolated Lighthouse Server Docker container with docker-compose stop. |
make lighthouse.rm |
Remove the stopped Lighthouse Server Docker container with docker-compose rm. |
make lighthouse.push.image |
Push the Lighthouse Server Docker image to GCR. |
make lighthouse.clean.image |
Clean the Lighthouse Server Docker image from the host machine. |
make lighthouse.build.cluster |
Build the Lighthouse Server GKE cluster. |
make lighthouse.creds |
Get the Lighthouse Server GKE cluster credentials. |
make lighthouse.tpl |
Generate the Lighthouse Server GKE YAML template. |
make lighthouse.deploy.cluster |
Deploy the Lighthouse Server GKE cluster. |
make lighthouse.get.cluster |
Get the Lighthouse Server GKE cluster status. |
make lighthouse.clean.cluster |
Clean the Lighthouse Server GKE cluster. |
This section described the components included in the Lighthouse integration with Tide, demonstrates the Lighthouse audit process, and provides example Tide API audit results.
The following outlines the components needed to integrate Lighthouse auditing of WordPress themes into the Tide API.
lighthouse-server
bin/lighthouse-server
built Lighthouse Server Go binary.cmd/lighthouse-server
Lighthouse Server Go source code.service/lighthouse-server
make
, Docker, and Kubernetes configurations.vendor
imported Go dependencies.The following demonstrates how a WordPress theme is run through a Lighthouse audit and has its results stored and returned via the Tide API.
gocloc
to get code information.https://wp-themes.com/<theme-slug>
) through a lighthouse
audit and keeps polling for the next job.POST
request from the Lighthouse Server.The following is a Tide API audit object showing a Lighthouse summary report.
http://tide.local/api/tide/v1/audit/wporg/theme/twentyseventeen/2.1
The following is a Tide API report object showing a download link to the original Lighthouse report. This demonstrates the local disk storage, a cloud provider will look a bit different and the URL will expire.
http://tide.local/api/tide/v1/report/236/raw/lighthouse