text:
// Copyright (c) 2006,2007,2008,2009,2010,2011 Tel-Aviv University (Israel).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
// You can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
//
// Author(s)     : Ron Wein           <wein@post.tau.ac.il>

#ifndef CGAL_FIG_STREAM_H
#define CGAL_FIG_STREAM_H

#include <CGAL/basic.h>
#include <CGAL/Polygon_2.h>

#include <vector>
#include <fstream>
#include <cstdio>

namespace CGAL {

/*!
 * FIG colors.
 */
enum Fig_color
{
  // Predefined colors:
  FIG_BLACK = 0,
  FIG_BLUE = 1,
  FIG_GREEN = 2,
  FIG_CYAN = 3,
  FIG_RED = 4,
  FIG_MAGENTA = 5,
  FIG_YELLOW = 6,
  FIG_WHITE = 7,
  FIG_BLUE_1 = 8, FIG_BLUE_2 = 9, FIG_BLUE_3 = 10, FIG_BLUE_4 = 11,
  FIG_GREEN_1 = 12, FIG_GREEN_2 = 13, FIG_GREEN_3 = 14,
  FIG_CYAN_1 = 15, FIG_CYAN_2 = 16, FIG_CYAN_3 = 17,
  FIG_RED_1 = 18, FIG_RED_2 = 19, FIG_RED_3 = 20,
  FIG_MAGENTA_1 = 21, FIG_MAGENTA_2 = 22, FIG_MAGENTA_3 = 23,
  FIG_BROWN_1 = 24, FIG_BROWN_2 = 25, FIG_BROWN_3 = 26,
  FIG_PINK_1 = 27, FIG_PINK_2 = 28, FIG_PINK_3 = 29, FIG_PINK_4 = 30,
  FIG_GOLD = 31,

  // User-defined colors:
  FIG_FIRST_USER_DEFINED_COLOR = 32,
  FIG_LAST_USER_DEFINED_COLOR = 543
};

/*!
 * FIG line styles.
 */
enum Fig_line_style
{
  FIG_SOLID = 0,
  FIG_DASHED = 1,
  FIG_DOTTED = 2,
  FIG_DASH_DOTTED = 3,
  FIG_DASH_DOUBLE_DOTTED = 4,
  FIG_DASH_TRIPLE_DOTTED = 5
};

#define FIG_DEFAULT_STYLE_VALUE   4.0

/*!
 * FIG fill styles.
 */
enum Fig_fill_style
{
  FIG_NOT_FILLED = -1,
  FIG_FILL_BLACK = 0,
  /// Values from 1 to 19 are shades of the color from darker to lighter.
  FIG_FILLED = 20,
  /// Values from 21 to 39 are tints of the color from the color to white.
  FIG_FILL_WHITE = 40,
  FIG_LEFT_DIAG_30DEG = 41,
  FIG_RIGHT_DIAG_30DEG = 42,
  FIG_CROSS_DIAG_30DEG = 43,
  FIG_LEFT_DIAG_45DEG = 44,
  FIG_RIGHT_DIAG_45DEG = 45,
  FIG_CROSS_DIAG_45DEG = 46,
  FIG_HORIZONTAL_BRICKS = 47,
  FIG_VERTICAL_BRICKS = 48,
  FIG_HORIZONTAL_LINES = 49,
  FIG_VERTICAL_LINES = 50,
  FIG_CROSS_LINES = 51,
  FIG_HORIZONTAL_RIGHT_SHINGLES = 52,
  FIG_HORIZONTAL_LEFT_SHINGLES = 53,
  FIG_VERTICAL_RIGHT_SHINGLES = 54,
  FIG_VERTICAL_LEFT_SHINGLES = 55,
  FIG_FISH_SCALES = 56,
  FIG_SMALL_FISH_SCALES = 57,
  FIG_CIRCLES = 58,
  FIG_HEXAGONS = 59,
  FIG_OCTAGONS = 60,
  FIG_HORIZONTAL_TIRE_TREADS = 61,
  FIG_VERTICAL_TIRE_TREADS = 62
};

/*!
 * FIG arrow types.
 */
enum Fig_arrow_type
{
  FIG_STICK = 0,
  FIG_TRIANGLE = 1,
  FIG_INDENTED_BUTT = 2,
  FIG_POINTED_BUTT = 3
};

/*!
 * Arrow modes (not based on the FIG format).
 */
enum Fig_arrow_mode
{
  FIG_NO_ARROW,
  FIG_FORWARD_ARROW,
  FIG_BACKWARD_ARROW,
  FIG_BOTH_ARROWS
};

/*!
 * Point styles (not based on the FIG format).
 */
enum Fig_point_style
{
  FIG_CROSS,
  FIG_PLUS,
  FIG_CIRCLE,
  FIG_DISC,
  FIG_SQUARE,
  FIG_BOX,
  FIG_RHOMBUS,
  FIG_DIAMOND
};

/*!
 * FIG fonts.
 */
enum Fig_font
{
  FIG_ROMAN = 1,
  FIG_BOLD = 2,
  FIG_ITALIC = 3,
  FIG_SANS_SERIF = 4,
  FIG_TYPEWRITER = 5
};

/*!
 * Depth constants.
 */
enum Fig_depth
{
  FIG_MIN_DEPTH = 0,
  FIG_DEFAULT_DEPTH = 50,
  FIG_MAX_DEPTH = 99
};

/*!
 * \class A class for writing geometric objects in a FIG format (version 3.2).
 * For more details, see: http://www.xfig.org/userman/fig-format.html
 */
template <class Kernel_>
class Fig_stream
{
public:

  typedef Kernel_                                Kernel;

  // Define the kernel objects.
  typedef typename Kernel::FT                    NT;
  typedef typename Kernel::Point_2               Point_2;
  typedef typename Kernel::Segment_2             Segment_2;
  typedef typename Kernel::Ray_2                 Ray_2;
  typedef typename Kernel::Line_2                Line_2;
  typedef typename Kernel::Triangle_2            Triangle_2;
  typedef typename Kernel::Iso_rectangle_2       Iso_rectangle_2;
  typedef Polygon_2<Kernel>                      Polygon_2;
  typedef typename Kernel::Circle_2              Circle_2;

protected:

  // Data members:
  std::ofstream           _ofile;       // The output file.

  Iso_rectangle_2         _bound_rect;  // A rectangle bounding the workspace.
  int                     _width;       // Figure width (in pixels).
  int                     _height;      // Figure height (in pixels).
  double                  _scale;       // Scaling factor.

  int                     _depth;

  Fig_color               _color;
  int                     _line_width;
  Fig_line_style          _line_style;
  double                  _style_value;

  Fig_color               _fill_color;
  Fig_fill_style          _fill_style;

  Fig_point_style         _point_style;
  NT                      _point_size;

  Fig_arrow_mode          _arrow_mode;
  Fig_arrow_type          _arrow_type;
  NT                      _arrow_width;
  NT                      _arrow_height;

  Fig_font                _font;
  int                     _font_size;

  bool                    colors[FIG_LAST_USER_DEFINED_COLOR + 1];

  // Kernel functors.
  typename Kernel::Intersect_2       intersect_func;

private:

  // Copy constructor and assignment operator - not supported.
  Fig_stream (const Fig_stream<Kernel>& );
  const Fig_stream<Kernel>& operator= (const Fig_stream<Kernel>& );

public:

  /// \name Constructors and destructor.
  //@{

  /*!
   * Default constructor.
   */
  Fig_stream () :
    _width (0),
    _height (0),
    _scale (0),
    _depth (FIG_DEFAULT_DEPTH),
    _color (FIG_BLACK),
    _line_width (1),
    _line_style (FIG_SOLID),
    _style_value (FIG_DEFAULT_STYLE_VALUE),
    _fill_color (FIG_WHITE),
    _fill_style (FIG_NOT_FILLED),
    _point_style (FIG_DISC),
    _arrow_mode (FIG_NO_ARROW),
    _arrow_type (FIG_STICK),
    _font (FIG_ROMAN),
    _font_size (12)
  {
    // Reset all colors.
    _reset_colors ();

    // Construct the necessary kernel functors.
    Kernel        ker;

    intersect_func = ker.intersect_2_object();
  }

  /*!
   * Constructor.
   * \param filename The name of the output FIG file.
   * \param rect A rectangle bounding the logical drawing area.
   * \param width The physical width of the figure (in FIG units).
   * \param height The physical height of the figure (in FIG units).
   * \pre The bounding rectangle is valid and the physical dimensions are
   *      both positive.
   */
  Fig_stream (const char *filename,
              const Iso_rectangle_2& rect,
              const int& width = 12000,
              const int& height = 12000) :
    _width (0),
    _height (0),
    _scale (0),
    _depth (FIG_DEFAULT_DEPTH),
    _color (FIG_BLACK),
    _line_width (1),
    _line_style (FIG_SOLID),
    _style_value (FIG_DEFAULT_STYLE_VALUE),
    _fill_color (FIG_WHITE),
    _fill_style (FIG_NOT_FILLED),
    _point_style (FIG_DISC),
    _arrow_mode (FIG_NO_ARROW),
    _arrow_type (FIG_STICK),
    _font (FIG_ROMAN),
    _font_size (12)
  {
    // Reset all colors.
    _reset_colors ();

    // Construct the necessary kernel functors.
    Kernel        ker;

    intersect_func = ker.intersect_2_object();

    // Open the file.
    open (filename, rect, width, height);
  }

  /*!
   * Destructor.
   */
  virtual ~Fig_stream ()
  {
    _ofile.close();
  }
  //@}

  /// \name Openning and closing the file.
  //@{

  /*!
   * Check whether the file is open.
   */
  bool is_open ()
  {
    return (_ofile.is_open());
  }

  /*!
   * Open a FIG file.
   * \param filename The name of the output FIG file.
   * \param rect A rectangle bounding the logical drawing area.
   * \param width The physical width of the figure (in FIG units).
   * \param height The physical height of the figure (in FIG units).
   * \pre The bounding rectangle is valid and the physical dimensions are
   *      both positive.
   * \return Whether the file was successfully opened.
   */
  bool open (const char *filename,
             const Iso_rectangle_2& rect,
             const int& width = 12000,
             const int& height = 12000)
  {
    CGAL_precondition (width > 0);
    CGAL_precondition (height > 0);
    CGAL_precondition (rect.xmax() > rect.xmin());
    CGAL_precondition (rect.ymax() > rect.ymin());

    // Reset all colors.
    _reset_colors ();

    // Close the current output file, if necessary.
    if (_ofile.is_open())
      _ofile.close();

    // Open the output file.
    _ofile.open (filename);

    // Set the logical and physical dimensions.
    _bound_rect = rect;
    _width = width;
    _height = height;

    // Compute the scale.
    const double x_scale = width / CGAL::to_double(rect.xmax() - rect.xmin());
    const double y_scale = height / CGAL::to_double(rect.ymax() - rect.ymin());
    _scale = (x_scale < y_scale) ? x_scale : y_scale;

    // Set the default point size and arrow dimensions.
    _point_size = (rect.xmax() - rect.xmin()) / NT(500);
    _arrow_width = _point_size;
    _arrow_height = 2*_point_size;

    // End here if the file is not opened.
    if (! _ofile.is_open())
      return (false);

    // Write the FIG header.
    _ofile << "#FIG 3.2" << std::endl;
    _ofile << "Landscape" << std::endl;
    _ofile << "Center" << std::endl;
    _ofile << "Inches" << std::endl;
    _ofile << "Letter" << std::endl;
    _ofile << "100.00" << std::endl;
    _ofile << "Single" << std::endl;
    _ofile << "-2" << std::endl;
    _ofile << "1200 2" << std::endl;

    return (true);
  }

  /*!
   * Close the FIG file.
   */
  void close ()
  {
    if (_ofile.is_open())
      _ofile.close();

    // Reset all colors.
    _reset_colors ();
  }
  //@}

  /// \name Accessing drawing properties.
  //@{

  /*!
   * Get the workspace bounding rectangle.
   */
  Iso_rectangle_2 bounding_rect() const
  {
      return (_bound_rect);
  }

/*   /\*! */
/*    * Set the workspace bounding rectangle. */
/*    *\/ */
/*   void set_bounding_rect(const Iso_rectangle_2& rect) */
/*   { */
/*       _bound_rect = rect; */
/*   } */

  /*!
   * Get the physical width of the fig
   */
  int width () const
  {
    return _width;
  }

  /*!
   * Get the physical height of the fig
   */
  int height () const
  {
    return _height;
  }

  /*!
   * Get the depth.
   */
  int depth () const
  {
    return (depth);
  }

  /*!
   * Get the color.
   */
  Fig_color color () const
  {
    return (_color);
  }

  /*!
   * Get the line width.
   */
  int line_width () const
  {
    return (line_width);
  }

  /*!
   * Get the line style.
   */
  Fig_line_style line_style () const
  {
    return (_line_style);
  }

  /*!
   * Get the style value.
   */
  double style_value () const
  {
    return (_style_value);
  }

  /*!
   * Get the fill color.
   */
  Fig_color fill_color () const
  {
    return (_fill_color);
  }

  /*!
   * Get the fill style.
   */
  Fig_fill_style fill_style () const
  {
    return (_fill_style);
  }

  /*!
   * Get the point style.
   */
  Fig_point_style point_style () const
  {
    return (_point_style);
  }

  /*!
   * Get the point size.
   */
  const NT& point_size () const
  {
    return (_point_size);
  }

  /*!
   * Get the arrow drawing mode (this mode is relevent when drawing segments,
   * polylines, circular arcs or splines).
   */
  Fig_arrow_mode arrow_mode () const
  {
    return (_arrow_mode);
  }

  /*!
   * Get the arrow type.
   */
  Fig_arrow_type arrow_type () const
  {
    return (_arrow_type);
  }

  /*!
   * Get the arrow width.
   */
  const NT& arrow_width () const
  {
    return (_arrow_width);
  }

  /*!
   * Get the arrow height.
   */
  const NT& arrow_height () const
  {
    return (_arrow_height);
  }

  /*!
   * Get the font.
   */
  Fig_font font () const
  {
    return (_font);
  }

  /*!
   * Get the font size.
   */
  int font_size () const
  {
    return (_font_size);
  }
  //@}

  /// \name Set the drawing properties.
  //@{

  /*!
   * Set the depth.
   */
  void set_depth (const int& depth)
  {
    if (depth < static_cast<int>(FIG_MIN_DEPTH))
      _depth = static_cast<int>(FIG_MIN_DEPTH);
    else if (depth > static_cast<int>(FIG_MAX_DEPTH))
      _depth = static_cast<int>(FIG_MAX_DEPTH);
    else
      _depth = depth;

    return;
  }

  /*!
   * Set the color.
   * \pre The color must be defined.
   */
  void set_color (const Fig_color& color)
  {
    CGAL_precondition (color_defined (color));

    if (color_defined (color))
        _color = color;

    return;
  }

  /*!
   * Set the line width.
   */
  void set_line_width (const unsigned int& width)
  {
    _line_width = static_cast<int>(width);
    return;
  }

  /*!
   * Set the line style.
   */
  void set_line_style (const Fig_line_style& style)
  {
    _line_style = style;
    return;
  }

  /*!
   * Set the style value.
   */
  void set_style_value (const double& val)
  {
    CGAL_precondition (val > 0);

    _style_value = val;
    return;
  }

  /*!
   * Set the fill color.
   * \pre The color must be defined.
   */
  void set_fill_color (const Fig_color& color)
  {
    CGAL_precondition (color_defined (color));

    if (color_defined (color))
        _fill_color = color;

    return;
  }

  /*!
   * Set the fill style.
   */
  void set_fill_style (const Fig_fill_style& style)
  {
    _fill_style = style;
    return;
  }

  /*!
   * Set the point style.
   */
  void set_point_style (const Fig_point_style& style)
  {
    _point_style = style;
    return;
  }

  /*!
   * Set the point size.
   */
  void set_point_size (const NT& size)
  {
    _point_size = CGAL::abs(size);
    return;
  }

  /*!
   * Set the arrow drawing mode. This mode will be applied when drawing
   * segments, polylines, circular arcs or splines.
   */
  void set_arrow_mode (const Fig_arrow_mode& mode)
  {
    _arrow_mode = mode;
    return;
  }

  /*!
   * Set the arrow type.
   */
  void set_arrow_type (const Fig_arrow_type& type)
  {
    _arrow_type = type;
    return;
  }

  /*!
   * Set the arrow width.
   */
  void set_arrow_width (const NT& width)
  {
    _arrow_width = CGAL::abs(width);
    return;
  }

  /*!
   * Get the arrow height.
   */
  void set_arrow_height (const NT& height)
  {
    _arrow_height = CGAL::abs(height);
    return;
  }

  /*!
   * Set the font.
   */
  void set_font (const Fig_font& font)
  {
    _font = font;
    return;
  }

  /*!
   * Set the font size.
   */
  void set_font_size (const unsigned int& size)
  {
    _font_size = static_cast<int>(size);
    return;
  }
  //@}

  /// \name Defining colors.
  //@{

  /*!
   * Check if a color is defined.
   */
  bool color_defined (const Fig_color& color) const
  {
    int     col = static_cast<int>(color);

    if (col < 0 || col > FIG_LAST_USER_DEFINED_COLOR)
        return (false);

    return (colors[col]);
  }

  /*!
   * Add a user-defined color.
   * Use this function after openning the FIG stream and before writing any
   * other object (i.e. before calling the write_<object> () functions).
   * \param color The color.
   * \param r The red component (0 - 255).
   * \param g The green component (0 - 255).
   * \param b The blue component (0 - 255).
   * \pre The color must be undefined.
   */
  void define_color (const Fig_color& color,
                     const unsigned char& r,
                     const unsigned char& g,
                     const unsigned char& b)
  {
    CGAL_precondition (color_defined (color));
    CGAL_precondition (_ofile.is_open());

    if (color_defined (color))
      return;

    // Prepare a string desribing the color.
    char    color_desc [10];

    sprintf ("#%02x%02x%02x", r, g, b);

    // Write the color to the FIG file.
    _ofile << "0 "                        // Desginates a color pseudo-object.
           << static_cast<int>(color) << ' '
           << color_desc << std::endl;

    // Mark that the color is now defined.
    colors[static_cast<int>(color)] = true;

    return;
  }

  //@}

  /// \name Writing objects.
  //@{

  /*!
   * Write a point.
   */
  void write_point (const Point_2& p)
  {
    CGAL_precondition (_ofile.is_open());

    //is the point outside the iso-rectangle?
    if(_bound_rect.has_on_unbounded_side(p))
      return;

    switch (_point_style)
    {
    case (FIG_CROSS):
    case (FIG_PLUS):
    {
      // Draw two segments intersecting at p.
      Point_2  s1, t1;
      Point_2  s2, t2;

      if (_point_style == FIG_PLUS)
      {
        // Draw a '+'.
        s1 = Point_2 (p.x() - _point_size, p.y());
        t1 = Point_2 (p.x() + _point_size, p.y());
        s2 = Point_2 (p.x(), p.y() - _point_size);
        t2 = Point_2 (p.x(), p.y() + _point_size);
      }
      else
      {
        // Draw an 'x'.
        s1 = Point_2 (p.x() - _point_size, p.y() - _point_size);
        t1 = Point_2 (p.x() + _point_size, p.y() + _point_size);
        s2 = Point_2 (p.x() - _point_size, p.y() + _point_size);
        t2 = Point_2 (p.x() + _point_size, p.y() - _point_size);
      }

      // Draw solid lines with width 1.
      _write_segment (Segment_2(s1, t1),
                      _color, 1, FIG_SOLID, _style_value,
                      false);
      _write_segment (Segment_2(s2, t2),
                      _color, 1, FIG_SOLID, _style_value,
                      false);

      break;
    }

    case (FIG_CIRCLE):
    {
      // Draw an empty circle (use a solid line with width 1).
      _write_ellipse (p,
                      CGAL::square(_point_size),
                      CGAL::square(_point_size),
                      _color, 1, FIG_SOLID, _style_value,
                      FIG_WHITE, FIG_NOT_FILLED);

      break;
    }

    case (FIG_DISC):
    {
      // Draw a filled disc.
      _write_ellipse (p,
                      CGAL::square(_point_size),
                      CGAL::square(_point_size),
                      _color, 1, FIG_SOLID, _style_value,
                      _color, FIG_FILLED);

      break;
    }

    case (FIG_SQUARE):
    case (FIG_BOX):
    case (FIG_RHOMBUS):
    case (FIG_DIAMOND):
    {
      // Prepare the rectangle vertices.
      std::vector<Point_2>   vertices (4);

      if (_point_style == FIG_SQUARE || _point_style == FIG_BOX)
      {
        vertices[0] = Point_2 (p.x() - _point_size, p.y() - _point_size);
        vertices[1] = Point_2 (p.x() - _point_size, p.y() + _point_size);
        vertices[2] = Point_2 (p.x() + _point_size, p.y() + _point_size);
        vertices[3] = Point_2 (p.x() + _point_size, p.y() - _point_size);
      }
      else
      {
        vertices[0] = Point_2 (p.x(), p.y() - _point_size);
        vertices[1] = Point_2 (p.x() + _point_size, p.y());
        vertices[2] = Point_2 (p.x(), p.y() + _point_size);
        vertices[3] = Point_2 (p.x() - _point_size, p.y());
      }

      if (_point_style == FIG_SQUARE || _point_style == FIG_RHOMBUS)
      {
        // Draw an empty rectangular shape (use a solid line with width 1).
        _write_polygon (4, vertices.begin(), vertices.end(),
                        _color, 1, FIG_SOLID, _style_value,
                        FIG_WHITE, FIG_NOT_FILLED);
      }
      else
      {
        // Draw a filled rectangular shape.
        _write_polygon (4, vertices.begin(), vertices.end(),
                        _color, 1, FIG_SOLID, _style_value,
                        _color, FIG_FILLED);
      }

      break;
      }
    }

    return;
  }

  /*!
   * Write a segment.
   */
  void write_segment (const Segment_2& seg)
  {
    CGAL_precondition (_ofile.is_open());

    // Clip the ray using the bounding rectangle.
    CGAL::Object    obj = intersect_func (_bound_rect, seg);
    Segment_2       clipped_seg;

    // Draw only the clipped segment (draw nothing if the segment does not
    // intersect the bounding rectangle).
    if (CGAL::assign (clipped_seg, obj))
    {
      _write_segment (clipped_seg,
                      _color, _line_width, _line_style, _style_value,
                      false);
    }

    return;
  }

  /*!
   * Write a ray.
   */
  void write_ray (const Ray_2& ray)
  {
    CGAL_precondition (_ofile.is_open());

    // Clip the ray using the bounding rectangle.
    CGAL::Object    obj = intersect_func (_bound_rect, ray);
    Segment_2       seg;

    // Draw only the clipped segment (draw nothing if the ray does not
    // intersect the bounding rectangle).
    if (CGAL::assign (seg, obj))
    {
      _write_segment (seg,
                      _color, _line_width, _line_style, _style_value,
                      false);
    }

    return;
  }

  /*!
   * Write a line.
   */
  void write_line (const Line_2& line)
  {
    CGAL_precondition (_ofile.is_open());

    // Clip the ray using the bounding rectangle.
    CGAL::Object    obj = intersect_func (_bound_rect, line);
    Segment_2       seg;

    // Draw only the clipped segment (draw nothing if the ray does not
    // intersect the bounding rectangle).
    if (CGAL::assign (seg, obj))
    {
      _write_segment (seg,
                      _color, _line_width, _line_style, _style_value,
                      false);
    }

    return;
  }

  /*!
   * Write a triangle.
   */
  void write_triangle (const Triangle_2& tri)
  {
    CGAL_precondition (_ofile.is_open());

    std::vector<Point_2>   vertices(3);

    vertices[0] = tri.vertex(0);
    vertices[1] = tri.vertex(1);
    vertices[2] = tri.vertex(2);

    _write_polygon (3, vertices.begin(), vertices.end(),
                    _color, _line_width, _line_style, _style_value,
                    _fill_color, _fill_style);
    return;
  }

  /*!
   * Write an iso-rectangle.
   */
  void write_rectangle (const Iso_rectangle_2& rect)
  {
    CGAL_precondition (_ofile.is_open());

    std::vector<Point_2>   vertices(4);

    vertices[0] = rect.vertex(0);
    vertices[1] = rect.vertex(1);
    vertices[2] = rect.vertex(2);
    vertices[3] = rect.vertex(3);

    _write_polygon (4, vertices.begin(), vertices.end(),
                    _color, _line_width, _line_style, _style_value,
                    _fill_color, _fill_style);
    return;
  }

  /*!
   * Write a polyline.
   * \param begin An iterator of the control points (of type Point_2).
   * \param end A past-the-end iterator for the control points.
   */
  template <class Input_iterator>
  void write_polyline (const Input_iterator& begin, const Input_iterator& end)
  {
    CGAL_precondition (_ofile.is_open());

    _write_polyline (begin, end,
                     _color, _line_width, _line_style, _style_value, false);
    return;
  }

  /*!
   * Write a polygon.
   */
  void write_polygon (const Polygon_2& pgn)
  {
    CGAL_precondition (_ofile.is_open());

    _write_polygon (pgn.size(),
                    pgn.vertices_begin(), pgn.vertices_end(),
                    _color, _line_width, _line_style, _style_value,
                    _fill_color, _fill_style);
    return;
  }

  /*!
   * Write a circle.
   */
  void write_circle (const Circle_2& circ)
  {
    CGAL_precondition (_ofile.is_open());

    _write_ellipse (circ.center(),
                    circ.squared_radius(), circ.squared_radius(),
                    _color, _line_width, _line_style, _style_value,
                    _fill_color, _fill_style);
    return;
  }

  /*!
   * Write a canonical ellipse.
   * \param center The center of the ellipse (the intersection of its axes).
   * \param r1_squared The squared length of the axis parallel to the x-axis.
   * \param r2_squared The squared length of the axis parallel to the y-axis.
   */
  void write_ellipse (const Point_2& center,
                      const NT& r1_squared, const NT& r2_squared)
  {
    CGAL_precondition (_ofile.is_open());

    _write_ellipse (center,
                    r1_squared, r2_squared,
                    _color, _line_width, _line_style, _style_value,
                    _fill_color, _fill_style);
    return;
  }

  /*!
   * Write a circular arc.
   * \param p1 The source point of the arc.
   * \param p2 A midpoint on the arc.
   * \param p3 The target point of the arc.
   * \pre The three points are not collinear.
   */
  void write_circular_arc (const Point_2& p1,
                           const Point_2& p2,
                           const Point_2& p3)
  {
    CGAL_precondition (_ofile.is_open());

    _write_arc (p1, p2, p3,
                _color, _line_width, _line_style, _style_value);
    return;
  }

  /*!
   * Write a spline.
   * \param begin An iterator of the control points (of type Point_2).
   * \param end A past-the-end iterator for the control points.
   * \param factor A shape factor for the spline: A value in the range [-1,1],
   *               where negative values are used for interpolated splines
   *               and positive values for approximated splines.
   *               The default value if 1.
   */
  template <class Input_iterator>
  void write_spline (const Input_iterator& begin, const Input_iterator& end,
                     const float& factor = 1)
  {
    CGAL_precondition (_ofile.is_open());

    if (begin == end)
      return;

    // Normalize the shape factor.
    float shape_factor;

    if (factor > 1)
      shape_factor = 1;
    else if (factor < -1)
      shape_factor = -1;
    else
      shape_factor = factor;

    _write_spline (begin, end, shape_factor,
                   _color, _line_width, _line_style, _style_value);
  }

  /*!
   * Write a text box.
   * \param pos The lower-left corner of the text box.
   * \param text The text to write.
   * \param angle The angle (in radians) that the text forms with the x-axis
   *              (0 by default).
   */
  void write_text (const Point_2& pos,
		   const char *text,
		   const double& angle = 0)
  {
    CGAL_precondition (_ofile.is_open());

    if (text == NULL || strlen(text) == 0)
      return;

    _write_text (pos,
		 reinterpret_cast<const unsigned char*>(text), strlen(text),
		 angle,
		 _color, _font, _font_size);
    return;
  }
  //@}

  /// \name Setting the draw properties via the << operator.
  //@{

  /*!
   * Set the depth.
   */
  Fig_stream& operator<< (const Fig_depth& depth)
  {
    set_depth (static_cast<int>(depth));
    return (*this);
  }

  /*!
   * Set the color.
   */
  Fig_stream& operator<< (const Fig_color& color)
  {
    set_color (color);
    return (*this);
  }

  /*!
   * Set the line style.
   */
  Fig_stream& operator<< (const Fig_line_style& style)
  {
    set_line_style (style);
    return (*this);
  }

  /*!
   * Set the fill style.
   */
  Fig_stream& operator<< (const Fig_fill_style& style)
  {
    set_fill_style (style);
    return (*this);
  }

  /*!
   * Set the point style.
   */
  Fig_stream& operator<< (const Fig_point_style& style)
  {
    set_point_style (style);
    return (*this);
  }

  /*!
   * Set the arrow drawing mode. This mode will be applied when drawing
   * segments, polylines, circular arcs or splines.
   */
  Fig_stream& operator<< (const Fig_arrow_mode& mode)
  {
    set_arrow_mode (mode);
    return (*this);
  }

  /*!
   * Set the arrow type.
   */
  Fig_stream& operator<< (const Fig_arrow_type& type)
  {
    set_arrow_type (type);
    return (*this);
  }

  /*!
   * Set the font.
   */
  Fig_stream& operator<< (const Fig_font& font)
  {
    set_font (font);
    return (*this);
  }
  //@}

  /// \name Drawing objects via the << operator.
  //@{

  /*!
   * Write a point.
   */
  Fig_stream& operator<< (const Point_2& p)
  {
    write_point (p);
    return (*this);
  }

  /*!
   * Write a line segment.
   */
  Fig_stream& operator<< (const Segment_2& seg)
  {
    write_segment (seg);
    return (*this);
  }

  /*!
   * Write a ray.
   */
  Fig_stream& operator<< (const Ray_2& ray)
  {
    write_ray (ray);
    return (*this);
  }

  /*!
   * Write a line.
   */
  Fig_stream& operator<< (const Line_2& line)
  {
    write_line (line);
    return (*this);
  }

  /*!
   * Write a triangle.
   */
  Fig_stream& operator<< (const Triangle_2& tri)
  {
    write_triangle (tri);
    return (*this);
  }

  /*!
   * Write a rectangle.
   */
  Fig_stream& operator<< (const Iso_rectangle_2& rect)
  {
    write_rectangle (rect);
    return (*this);
  }

  /*!
   * Write a polygon.
   */
  Fig_stream& operator<< (const Polygon_2& pgn)
  {
    write_polygon (pgn);
    return (*this);
  }

  /*!
   * Write a circle.
   */
  Fig_stream& operator<< (const Circle_2& circ)
  {
    write_circle (circ);
    return (*this);
  }
  //@}

protected:

  /*!
   * Convert a point to FIG units.
   */
  void _convert_point (const Point_2& p,
                       int& ix, int& iy) const
  {
    ix = static_cast<int> (_scale *
                           CGAL::to_double(p.x() - _bound_rect.xmin()));
    iy = static_cast<int> (_scale *
                           CGAL::to_double( _bound_rect.ymax() - p.y()));
    return;
  }

  /*!
   * Write a segment.
   */
  void _write_segment (const Segment_2& seg,
                       const Fig_color&      line_color,
                       const int&            line_width,
                       const Fig_line_style& line_style,
                       const double&         style_value,
                       const bool&      draw_arrows)
  {
    // Convert the segment to a polyline with two points and write it.
    std::vector<Point_2>   points (2);

    points[0] = seg.source();
    points[1] = seg.target();

    _write_polyline (points.begin(), points.end(),
                     line_color, line_width, line_style, style_value,
                     draw_arrows);
    return;
  }

  /*!
   * Write a polyline.
   */
  template <class Input_iterator>
  void _write_polyline (Input_iterator begin, Input_iterator end,
                        const Fig_color&      line_color,
                        const int&            line_width,
                        const Fig_line_style& line_style,
                        const double&         style_value,
                        const bool&      draw_arrows)
  {
    // Check if we should draw arrows.
    bool    forward_arrow = false;
    bool    backward_arrow = false;

    if (draw_arrows)
    {
      forward_arrow = (_arrow_mode == FIG_FORWARD_ARROW) ||
                      (_arrow_mode == FIG_BOTH_ARROWS);
      backward_arrow = (_arrow_mode == FIG_BACKWARD_ARROW) ||
                       (_arrow_mode == FIG_BOTH_ARROWS);
    }

    // Count the number of points in the spline.
    int     n_points = std::distance (begin, end);

    // Write the segment properties.
    _ofile << "2 1 "                      // Desginate a polyline.
           << line_style << ' '
           << line_width << ' '
           << line_color << ' '
           << FIG_WHITE << ' '            // Fill color (dummy).
           << _depth << ' '
           << "0 "                        // Pen style (not in use, always 0).
           << FIG_NOT_FILLED << ' '
           << style_value << ' '
           << "0 "                        // Join style (always 0).
           << "0 "                        // Cap style (always 0).
           << "-1 "                       // Radius (not in use for lines).
           << forward_arrow << ' '
           << backward_arrow << ' '
           << n_points << std::endl;

    // Write the points defining the polyline.
    bool             is_first = true;
    int              ix, iy;

    while (begin != end)
    {
      if (is_first)
      {
        _ofile << '\t';
        is_first = false;
      }
      else
      {
        _ofile << ' ';
      }

      _convert_point (*begin, ix, iy);
      _ofile << ix << ' ' << iy;

      begin++;
    }
    _ofile << std::endl;

    // Write the arrows, if necessary.
    if (forward_arrow)
        _write_arrow_line ();

    if (backward_arrow)
        _write_arrow_line ();

    return;
  }

  /*!
   * Write a polygon, reprsented as a range of points.
   */
  template <class Input_iterator>
  void _write_polygon (const int n_points,
                       Input_iterator begin, Input_iterator end,
                       const Fig_color&      line_color,
                       const int             line_width,
                       const Fig_line_style& line_style,
                       const double&         style_value,
                       const Fig_color&      fill_color,
                       const Fig_fill_style& fill_style)
  {
    // Write the polyline properties.
    _ofile << "2 3 "                      // Desginate a polygon.
           << line_style << ' '
           << line_width << ' '
           << line_color << ' '
           << fill_color << ' '
           << _depth << ' '
           << "0 "                        // Pen style (not in use, always 0).
           << fill_style << ' '
           << style_value << ' '
           << "0 "                        // Join style (always 0).
           << "0 "                        // Cap style (always 0).
           << "-1 "                       // Radius (not in use for lines).
           << "0 "                        // No forward arrow.
           << "0 "                        // No backward arrow.
           << n_points + 1 << std::endl;

    // Write the points.
    bool             is_first = true;
    Point_2          first = *begin;
    int              ix, iy;

    while (begin != end)
    {
      if (is_first)
      {
        _ofile << '\t';
        is_first = false;
      }
      else
      {
        _ofile << ' ';
      }

      _convert_point (*begin, ix, iy);
      _ofile << ix << ' ' << iy;

      begin++;
    }

    // Write the first point again.
    _convert_point (first, ix, iy);
    _ofile << ' ' << ix << ' ' << iy << std::endl;

    return;
  }

  /*!
   * Write an ellipse.
   */
  void _write_ellipse (const Point_2& center,
                       const NT& squared_radius_x,
                       const NT& squared_radius_y,
                       const Fig_color&      line_color,
                       const int&            line_width,
                       const Fig_line_style& line_style,
                       const double&         style_value,
                       const Fig_color&      fill_color,
                       const Fig_fill_style& fill_style)
  {

    // Write the ellipse properties.
    _ofile << "1 1 "                      // Desginate an ellipse.
           << line_style << ' '
           << line_width << ' '
           << line_color << ' '
           << fill_color << ' '
           << _depth << ' '
           << "0 "                        // Pen style (not in use, always 0).
           << fill_style << ' '
           << style_value << ' '
           << "1 "                        // Direction (always 1).
           << "0.000 ";                   // Angle (in radians).

    // Write the center point.
    int     ix, iy;

    _convert_point (center, ix, iy);
    _ofile << ' ' << ix << ' ' << iy;

    // Write the radii.
    int  rx = static_cast<int> (_scale *
                                std::sqrt(CGAL::to_double(squared_radius_x)));
    int  ry = static_cast<int> (_scale *
                                std::sqrt(CGAL::to_double(squared_radius_y)));

    _ofile << ' ' << rx << ' ' << ry;

    // Write the start point (the center) and the end point (one corner of
    // the rectangles bounding the ellipse).
    _ofile << ' ' << ix << ' ' << iy
           << ' ' << (ix + rx) << ' ' << (iy +ry) << std::endl;

    return;
  }

  /*!
   * Write an arc.
   */
  void _write_arc (const Point_2& p1, const Point_2& p2, const Point_2& p3,
                   const Fig_color&      line_color,
                   const int&            line_width,
                   const Fig_line_style& line_style,
                   const double&         style_value)
  {
    // Check if we should draw arrows.
    bool    forward_arrow;
    bool    backward_arrow;

    forward_arrow = (_arrow_mode == FIG_FORWARD_ARROW) ||
                  (_arrow_mode == FIG_BOTH_ARROWS);
    backward_arrow = (_arrow_mode == FIG_BACKWARD_ARROW) ||
                   (_arrow_mode == FIG_BOTH_ARROWS);

    // Construct the supporting circle of the arc and use its center and
    // orientation.
    Circle_2   circ (p1, p2, p3);
    int        orient = (circ.orientation() == CGAL::CLOCKWISE) ? 0 : 1;

    // Write the arc properties.
    _ofile << "5 1 "                      // Desginate an open arc.
           << line_style << ' '
           << line_width << ' '
           << line_color << ' '
           << FIG_WHITE << ' '            // Fill color (dummy).
           << _depth << ' '
           << "0 "                        // Pen style (not in use, always 0).
           << FIG_NOT_FILLED << ' '
           << style_value << ' '
           << "0 "                        // Cap style (always 0).
           << orient << ' '
           << forward_arrow << ' '
           << backward_arrow << ' ';

    // Write the center of the circle.
    int     ix, iy;

    _convert_point (circ.center(), ix, iy);
    _ofile << ix << ' ' << iy;

    // Write the three points defining the arc.
    _convert_point (p1, ix, iy);
    _ofile << ' ' << ix << ' ' << iy;

    _convert_point (p2, ix, iy);
    _ofile << ' ' << ix << ' ' << iy;

    _convert_point (p3, ix, iy);
    _ofile << ' ' << ix << ' ' << iy << std::endl;

    // Write the arrows, if necessary.
    if (forward_arrow)
        _write_arrow_line ();

    if (backward_arrow)
        _write_arrow_line ();

    return;
  }

  /*!
   * Write a spline
   */
  template <class Input_iterator>
  void _write_spline (Input_iterator begin, Input_iterator end,
                      const float& factor,
                      const Fig_color&      line_color,
                      const int&            line_width,
                      const Fig_line_style& line_style,
                      const double&         style_value)
  {
    // Check if we should draw arrows.
    bool    forward_arrow;
    bool    backward_arrow;

    forward_arrow = (_arrow_mode == FIG_FORWARD_ARROW) ||
                  (_arrow_mode == FIG_BOTH_ARROWS);
    backward_arrow = (_arrow_mode == FIG_BACKWARD_ARROW) ||
                   (_arrow_mode == FIG_BOTH_ARROWS);

    // Count the number of points in the spline.
    int     n_points = std::distance (begin, end);

    // Write the spline properties.
    _ofile << "3 0 "                      // Desginate an open spline.
           << line_style << ' '
           << line_width << ' '
           << line_color << ' '
           << FIG_WHITE << ' '            // Fill color (dummy).
           << _depth << ' '
           << "0 "                        // Pen style (not in use, always 0).
           << FIG_NOT_FILLED << ' '
           << style_value << ' '
           << "0 "                        // Cap style (always 0).
           << forward_arrow << ' '
           << backward_arrow << ' '
           << n_points << std::endl;

    // Write the points defining the spline.
    bool             is_first = true;
    int              ix, iy;

    while (begin != end)
    {
      if (is_first)
      {
        _ofile << '\t';
        is_first = false;
      }
      else
      {
        _ofile << ' ';
      }

      _convert_point (*begin, ix, iy);
      _ofile << ix << ' ' << iy;

      begin++;
    }
    _ofile << std::endl;

    // Write the shape factors: 0 for the endpoints and (factor) for each
    // of the midpoints.
    int     i;

    _ofile << '\t' << "0.000";
    for (i = 0; i < n_points - 2; i++)
      _ofile << ' ' << factor;
    _ofile << '\t' << "0.000" << std::endl;

    // Write the arrows, if necessary.
    if (forward_arrow)
        _write_arrow_line ();

    if (backward_arrow)
        _write_arrow_line ();

    return;
  }

  /*!
   * Write an arrow line.
   */
  void _write_arrow_line ()
  {
    int  width  = static_cast<int> (_scale * CGAL::to_double(_arrow_width));
    int  height = static_cast<int> (_scale * CGAL::to_double(_arrow_height));

    _ofile << _arrow_type << ' '
           << "0 "                        // Arrow style (always 0).
           << _line_width << ' '
           << width << ' '
           << height << std::endl;
    return;
  }

  /*!
   * Write a text box.
   */
  void _write_text (const Point_2& pos,
		    const unsigned char *text,
		    const int&          len_text,
		    const double& angle,
		    const Fig_color& font_color,
		    const Fig_font&  font,
		    const int&       font_size)
  {
    // Compute the text-box dimensions.
    const int    text_height = font_size * 1200 / 80;
    const int    text_width = len_text * font_size * 1200 / 160;

    // Write the text properties.
    _ofile << "4 0 "                      // Desginate left-justified text.
	   << font_color << ' '
	   << _depth << ' '
	   << "0 "                        // Pen style (not in use, always 0).
	   << font << ' '
	   << font_size << ' '
	   << angle << ' '
	   << "2 "                        // Indicates a special LaTeX font.
	   << text_height << ' '
	   << text_width;

    // Write the position coordinates.
    int     ix, iy;

    _convert_point (pos, ix, iy);
    _ofile << ' ' << ix << ' ' << iy << ' ';

    // Write the text.
    char    oct[10];
    int     i;

    for (i = 0; i < len_text; i++)
    {
      if (text[i] >= ' ' && text[i] < 128 && text[i] != '\\')
      {
	// If the current character is printable, just write it.
	_ofile << static_cast<char>(text[i]);
      }
      else
      {
	// Convert the current character to an octal string and write it.
	sprintf (oct, "\\%03o", text[i]);
	_ofile << oct;
      }
    }

    // Write the end-of-string sequence.
    _ofile << "\\001" << std::endl;

    return;
  }

  /*!
   * Reset all user-defined colors.
   */
  void _reset_colors ()
  {
    int     i;

    for (i = 0; i < FIG_FIRST_USER_DEFINED_COLOR; i++)
        colors[i] = true;

    for (i = FIG_FIRST_USER_DEFINED_COLOR;
         i < FIG_LAST_USER_DEFINED_COLOR; i++)
    {
        colors[i] = false;
    }

    return;
  }
};

} //namespace CGAL

#endif

redpajama_set_name: RedPajamaGithub


text:
Subscribe to MFWire.com's News Alerts [click]
Rating: Email & Route Print
Money Management and Squash are Similar, Says Delaware CEO
Reported by Armie Margaret Lee
Delaware Investments has inked a three-year agreement to sponsor the U.S. Open Squash Championships. Financial terms of the deal were not made public.
Pat Coyne
Delaware Investments
"As a global asset manager, we are excited to be involved with a sport that has such a strong global reach," said Delaware president and CEO Pat Coyne in a press release. "Squash is an intense, competitive, fast-paced sport -- similar to money management these days."
This year's tournament will be held September 30-October 6 at Drexel University in Delaware's home city of Philadelphia. Delaware will be the title sponsor.
Company Press Release Delaware Investments Signs On As Title Sponsor Of 2011 U.S. Open Squash Championships Tournament Slated for September 30th -- October 6th, at Drexel University
NEW YORK, Sep 08, 2011 -- U.S. SQUASH and Delaware Investments announced the completion of a multiyear sponsorship agreement for the U.S. Open Squash Championships. Under the agreement Delaware Investments will be the title sponsor for this year's tournament, being held September 30th- October 6th, in Philadelphia, PA. The tournament will take place at the Daskalakis Athletic Center, adjacent to the newly renovated Drexel Recreation Center, on the campus of Drexel University.
Delaware Investments, a member of Macquarie Group, is a diversified asset management firm with more than $155 billion in assets under management as of 6/30/2011. Through a team of talented investment professionals, the firm manages assets across all major asset classes for a wide range of institutional and individual investors. Delaware Investments President and CEO Patrick P. Coyne remarked, "As a global asset manager, we are excited to be involved with a sport that has such a strong global reach. Squash is an intense, competitive, fast --paced sport-similar to money management these days. We identify with these world-class athletes as we also strive every day to excel for the benefit of our clients. We look forward to our partnership with U.S. SQUASH and to showing the local community that this week there's more than one ball game in town."
The World's top ranked men and women have entered the 2011 U.S. Open Championships, led by World #1's Nick Matthew and Nicol David, who will compete for $175,000 in combined prize money and the most prestigious squash title in the US. The thirty-two player men's main draw will feature 22 of the top ranked 25 men while the sixteen player women's draw will feature 13 of the top 16 ranked women.
The tournament will be streamed worldwide on psasquashtv.com, with the semifinals and finals also being streamed on ESPN3. Fox Television will also be broadcasting the tournament in Australia and Malaysia.
More information and buy tickets for the 2011 U.S. Open Squash Championships are available on usopensquash.com.
About U.S. SQUASH
U.S. SQUASH is the national governing body and membership organization for the sport of squash in the United States and is a not-for-profit 501(c)3 organization. U.S. SQUASH is a member of the U.S. Olympic Committee and squash is considered an Olympic-level sport, however, it is not currently on the Olympic Program.
U.S. SQUASH owns and operates tournaments including the United States and North American Opens as well as all other United States National Championships. U.S. SQUASH also selects and manages the U.S. National Teams that compete internationally, maintains the official ratings and rankings system for the U.S., and invests in programs to grow participation in the sport at every level.
U.S. SQUASH's vision is for all people to have the opportunity to enhance their health and well being through the sport of squash. U.S. SQUASH's mission is to enhance people's health and well being by increasing participation in squash, to enrich the experiences of our members of all ages, and to build awareness of the sport, valuing excellence, professionalism and fiscal responsibility.
Stay ahead of the news ... Sign up for our email alerts now
Do You Recommend This Story?
GO TO: MFWire
2019: Q3 Q2 Q1
2018: Q4 Q3 Q2 Q1
Subscribe via RSS:
Raw XML
Timing Matters
Click Here to See Why
The MFWire.com
Expect Miracles Merges [7/16/2019]
First Trust Dethrones Baird [7/16/2019]
An ETF Guru Teams Up For Online TV [7/16/2019]
ETF Newcomer Passes $100MM In AUM [7/15/2019]
The Three ETF Titans Crushed It In June [7/15/2019]
Week In Preview, July 15-21 [7/15/2019]
An Ex-Schroders Sales Exec Lands at NYL [7/12/2019]
An M* Vet Takes Over a Midwestern Fund Firm [7/12/2019]
MFS Hires a 23-Year OpFunds Vet [7/11/2019]
Rogers Shares the Reins [7/11/2019]
An NYC Fund Firm Lays Off Dozens [7/3/2019]
Will the Low-Cost Leviathan Retry This Next? [6/25/2019]
An Analytics and Sales Exec Leaves Allianz [6/21/2019]
Check These Boxes to Make Sure Your Content Is Worthwhile [6/27/2019]
After Fidelity, an Ousted Star Becomes a Hedge Fundster [6/18/2019]
A Serial VP Lands at Eaton Vance [7/1/2019]
RMB Rebrands Two Funds and Transforms a Third [7/5/2019]
The $6-Billion Question About M&A [7/18/2019]
A $789B Asset Manager Dodges "Deep Cuts" At Its Parent [7/9/2019]
A Relocating Fundster CEO Finds His New HQ [7/11/2019]
What Does Gundlach Think of Trump 2020? [6/27/2019]
A Money Center Bank's AM Chief Retires [6/20/2019]
Will M* Take Its Ratings Up a Notch Or Two? [6/19/2019]
Victory Saves Another $10MM While Sealing the Deal [7/2/2019]
Go to Complete List
The most searched for terms on The MFWire for the past month.
first eagle
ria channel

redpajama_set_name: RedPajamaCommonCrawl


text:
Louisiana Cajun Country Volume 1 è un album discografico di Doug Kershaw, pubblicato dall'etichetta discografica Starflite Recordings nel 1979.

Tracce

LP
Lato A

Lato B

Musicisti
 Doug Kershaw – voce, strumenti vari
 Ed Kershaw – voce (brani: Big Ed Special e Mama & Papa Waltz)
 Altri musicisti non accreditati
Note aggiuntive
 Huey P. Meaux – produttore, note retrocopertina album originale
 Registrazioni effettuate al Sugar Hill Studios 1-2-3 di Houston, Texas (Stati Uniti)
 Bert Frilot, Dennis Krash Collins e Roger Harris – ingegneri delle registrazioni
 James Darby – cover art copertina album originale

Note

Collegamenti esterni
  (LP - Titoli e durata brani - Produttore)

redpajama_set_name: RedPajamaWikipedia


Couples who have concerns about important topics like money, may have strong feelings about their problem and may find it difficult for them to work together in their partnership or marriage.
Our set of videos here show a fictional scenario like this. In the first video the different views about finances creates a viscous cycle of arguing where couples say things that hurt each other that they don't mean.
Couple therapists are trained to enhance open and even communication and create a better environment for couples to deal with major challenges such as this. In the second video we show how the pair may approach with things in a different way.
If you find it is hard for you to talk with each other about your problems, seek couple or individual therapy at Tavistock Relationships. You can book an appointment to see us in London.
Alternatively if you can't access our central London offices, our Online therapy is available here.


text:
Cat Island National Wildlife Refuge
Fish and Wildlife Service, Mississippi.
Cat Island National Wildlife Refuge was established on October 27, 2000 as the 526th refuge in the National Wildlife Refuge System. It is located near the town of St. Francisville, Louisiana, which is 30 miles north of Baton Rouge. The refuge was established to conserve, restore, and manage native forested wetland habitats for migratory birds, aquatic resources, and endangered and threatened plants and animals. Additionally, it was created to encourage the use of volunteers and facilitate partnerships among the U.S. Fish and Wildlife Service, local communities, and conservation organizations to promote public awareness of resources of the refuge and the National Wildlife Refuge System.
Interpretive Programs
Cat Island National Wildlife Refuge is located in St. Francisville, Louisiana, approximately 30 miles north of Baton Rouge. This refuge is administered from St. Catherine Creek National Wildlife Refuge in Sibley, Mississippi. In general, we strongly recommend you do not rely on an electronic navigation device to find your way around the refuge. Inaccurate maps and limited reception can lead you astray. For visitor information, please stop at the St. Francisville Historical Society at 11757 Ferdinand Street in St. Francisville, Louisiana 70775. Visitor maps are also located at the entrance to the refuge.
From Natchez, MS: From U.S. Highway 61S, turn right onto Highway 66 and turn left (west toward Angola). Continue 1.5 miles, and then turn left on Solitude Road. Continue approximately 3.5 miles, and then turn right at the refuge sign. Continue another 1.5 miles to the refuge entrance.
From St. Francisville, LA: From Commerce St. take Ferdinand St. one mile and take a right on Mahoney Rd. Go three miles, cross the low-water crossing bridge and take a left on Creek Rd. Take a slight left to stay on Creek Rd. Creek Rd continues to the Cat Island NWR Entrance. Be aware that this route may not be accessible when river levels are high.


text:
» Subscribe Today!
The Power of Information
The Ledger - EST. 1978 - Nashville Edition
Home | About Us | Archive | Distribution Locations
Jobs Homes For Sale Open Houses Rentals Rates All Classifieds
Help | Your Account | Contact Us | Log In | Subscribe
NAME & PROPERTY SEARCH »
Research millions of people and properties [+]
Name Property
Friday, Jan. 17, 2020Friday, Jan. 10, 2020Friday, Jan. 3, 2020Friday, Dec. 27, 2019Friday, Dec. 20, 2019
« Back | Forward »
Go to date:
Friday, Jan. 17, 2020Thursday, Jan. 16, 2020Wednesday, Jan. 15, 2020Tuesday, Jan. 14, 2020Monday, Jan. 13, 2020
Search Records:
Search Notices:
Home > Article
VOL. 42 | NO. 20 | Friday, May 18, 2018
Blockchain tech 'is the shiny new penny'
By Jeannie Naujeck | Correspondent
Print | Front Page | Email this story
From (email):
During the General Assembly session that just ended legislators debated a number of hot-button issues: guns, abortion, Confederate statues and medical marijuana.
But tucked among the headline-grabbers was a brief bill, less than 300 words long, that attracted no controversy whatsoever.
Not only did it pass both houses with bipartisan support, it passed with unanimous support – despite being concerned with an esoteric technology that some legislators had never heard of.
The bill that united legislators this session was an official recognition of blockchain, an emerging technology that could transform the operations of any business that depends on secure, transparent, efficient transactions – including some of Tennessee's most important industries.
What likely sold legislators, even if they didn't quite understand the technology, was its potential to attract new business to the state.
"Any state worth its salt wants to compete for business," says Joan MacLeod Heminway, a corporate and securities lawyer and professor of law at the University of Tennessee-Knoxville.
"Blockchain technology is the shiny new penny, and everyone wants to jump on the bandwagon, because if you don't you might get left behind. Tennessee is a very entrepreneurial state, and we like to make sure that if entrepreneurs think they need something we give it to them."
Many people know blockchain as the technology that powers cryptocurrencies like bitcoin, which hit the news with its huge run-up in value last year, making digital millionaires of those who got in on the ground floor. But the technology has far greater implications for the Tennessee economy.
"Blockchain is a new and exciting industry with almost unlimited potential in different applications," explains Rep. Jason Powell, a Democrat who sponsored the House bill. Steve Dickerson, a Republican, sponsored it in the Senate.
Luis A. del Mazo, Jr., right, shares some thoughts on bitcoins and blockchain during a Bitcoins and Beer meet up group at The Village Pub in East Nashville.
-- Michelle Morrow
"I think there is tremendous upside, and it's great that Tennessee has planted a flag to say that we are open for business when it comes to blockchain, and hopefully, can continue to foster either businesses starting up or moving here that are in that space."
A lot of smart money is betting on blockchain – or its broader term, distributed ledger technology – due to its potential impact on the health care, real estate, transportation and logistics, and even music industries.
In Nashville, health care giants like HCA, established companies such as Change Healthcare, and start-ups like Hashed Health are investing in new blockchain-based products to improve operational efficiency. Music executives and artists are talking about how to leverage blockchain for digital rights managements and payments.
In Memphis, FedEx is piloting blockchain-based solutions to dispute resolutions.
In Chattanooga, home to two of the largest truckload carriers in North America and almost 30 freight brokers, a consortium called the Blockchain in Transport Alliance has sprung up to promote the development of blockchain technology applications for the nearly trillion-dollar freight industry, which includes major players such as Bridgestone.
"With Nashville being a hub for health care IT and Chattanooga being sort of a logistics hub, there is just tons of room for growth and innovation in those markets," says T.J. Gentle, a startup veteran and attorney with Miller & Martin's Chattanooga office.
"Block chain technology really started as a grassroots effort from developers who were libertarian-minded and wanted to sort of decentralize transactions from a centralized government or a centralized bank.
"But it turns out that the technology used to create this system is incredibly useful for doing things like validating who people are, securing records and data in a way that makes it easy to see who accessed that information and who has the credentials to access that. So, it lends itself really well to industries where we are emerging as hubs of our respective technology sectors."
John Davis shares during a Bitcoins and Beer meet up group at The Village Pub in East Nashville.
Powell adds even his business, real estate, is abuzz about the possibilities of sharing data securely and simultaneously between the many parties involved in a sale: buyers, sellers, agents, attorneys and banks.
"Every time I go to a conference, someone asks about the application of blockchain in real estate," he says.
"When you look at some of the numbers and how much money is being invested into certain blockchain initiatives, the ways that it can potentially revolutionize different industries, it's already making a difference."
Last year, blockchain startups attracted over $900 million in traditional venture capital rounds (not counting initial coin offerings), according to Crunchbase. Investment this year may well exceed that.
"One technology generation ago, some of the world's smartest people were spending all their time trying to figure out how to get people to click on an ad," Gentle says.
"Now they're figuring out how to take this technology and create a better product."
What is it and how does it work?
Distributed ledger technology – a broader term that includes and is often shortened to blockchain – is an underlying decentralized digital records system that powers digital (or crypto) currencies like bitcoins. (A simplistic but useful analogy is to think of bitcoin as an application of blockchain in the same way that email or Uber is an application of the internet.)
The term "ledger" refers to the total record of all actions associated with a transaction on a blockchain platform. It is distributed to multiple computers, decentralized, shared and replicated, with access allowed to authorized users. Data is encrypted and is immutable unless changed by an authorized user.
Any changes become part of the "ledger" and are updated simultaneously and in real time so that all parties who are verified to access the data can see it at once.
Bitcoins and Beer meet up group in East Nashville spend some time together at The Village Pub.
By definition, blockchain is decentralized, so no one governing body – whether it be bank, store, or corporation – "owns" data. Because of this, blockchain allows for peer-to-peer transactions, just as Napster allowed people to share digital music files amongst themselves, cutting out the record labels, music stores, artists and others who normally would have gotten paid from the transaction.
Essentially, distributed ledger technology returns the internet to the open-source Napster days – before platforms like iTunes, Facebook and Airbnb applied corporate business models on top of such transactions. Blockchain technology also helps solve a critical element that was left open during the early evolution of the internet: that of establishing one's online identity.
In a blockchain environment identities can be established and verified, and "follow" a person through all his or her digital transactions. This can aid and simplify any number of transactions a person participates in through the course of his or her everyday life.
For corporate entities, platforms can be built on blockchain networks to simplify and accelerate business transactions.
Hashing the cost out of health care
Large corporations are starting to invest heavily in blockchain technology. In Nashville, startups like Hashed Health are also generating a lot of buzz. Hashed Health builds blockchain solutions for problems in the health care industry including consumer payments, supply chain management and provider credentialing.
Last year, the company secured $2 million in funding from investors including Martin Ventures and formed a relationship with Change Healthcare, which recently launched its own blockchain-based network that can be used by hospitals, physician practices and insurance companies for tracking medical claims and payments.
Giles Ward, COO of Hashed Health, a Nashville tech company, that applies blockchain to the healthcare industry.
Refreshingly, Hashed Health defies the youth-obsessed stereotype of tech companies: its executives bring many years of experience in health care to the table. Because of this maturity and understanding of a complex system, Hashed Health spends plenty of time saying no to projects.
"There are so many places where blockchain makes sense that we don't have to be a disruptive technology," notes Giles Ward, chief operating officer.
"We have a very sophisticated healthcare system. It's not efficient, it's not sustainable, but it's not dumb. And the low-hanging fruit is of such great value that we can spend the next 10 years providing measurable advancement and value and cost savings and efficiency without ever having to touch the system as it is right now."
One of those areas is physician credentialing, a necessary but tedious function that is fraught with delays, costs and redundancies.
Whenever a physician makes a career move, a new employer must verify credentials like medical school graduation, residency completions, state licensing, biannual recertifications and more. But that process is repeated over and over throughout a physician's career. To solve it, Hashed Health has built a product called Professional Credentials Exchange (ProCredX).
"If I graduate from med school and apply for a license with the state of Tennessee, they check, I think, 18 things. And then I get my license and walk over to HCA to apply for a job and they check those same things," Ward explains.
"Nothing has changed. But it can take months. And even if you don't move, that stuff is being checked again and again. The block chain provides the signature that says, 'Here's a time-stamped and cryptographically guaranteed signature that says nothing in this record has been altered since it was checked.'"
With ProCredX, once a trusted source performs a verification, it becomes a permanent digital asset and "follows" the person so subsequent employers don't have to check.
"Now, the second and third time that a doctor goes to a new clinic, the employer can just query the system and say, 'Of the 20 items we need to credential this doctor to practice here, 18 of them have been checked.
Three different people have called Vanderbilt, all three of them said yes, he graduated from med school, and the record they've created not only says, I've checked it and it's valid, but those three records look the same,'" Ward says.
"And so, with reasonable certainty you can accept that credential without picking up the phone."
The product utilizes a central feature of blockchain technology: the ability to establish a verifiable digital identity – a sort of "permanent record" that can follow a person and simplify any number of transactions he or she participates in through the course of his or her everyday life. That element was never established by the early architects of the internet and represents a new phase in its evolution.
"The first phase we had was the information phase, where people for the first time were able to connect to a network and access information all over the world," Gentle says.
"The next phase was the social phase, where people came online and started interacting with each other.
"This next phase is the internet of value, where we will be able to build on what's happened in the social phase and use the block chain to create more trust, and the system to verify that who we are talking to is who we think it is, and that companies are doing what they're supposed to do."
An invisible change
If distributed ledger technology fulfills its promise, consumers may not even notice. They'll just find everyday transactions getting faster and easier, powered by large corporations like Google, Microsoft, Intel and IBM that are investing heavily in blockchain platforms.
"If blockchain is adopted in the right way, people won't even see the difference," Gentle points out.
"There will just be fewer instances of breaches, of consumer data and more security, more transparency in what's happening with people's information and how people transact. And more efficiency."
Gray Sasser
Blockchain's ability to facilitate peer-to-peer transactions will threaten some business models, like banks and credit card companies, who could miss out on their cut if people make direct transactions with merchants. But it also carries increased risk.
"Part of the benefit of the bargain when we use these credit card companies and banks, is that they create the security, a way for us to ensure that the transaction is valid," Gentle acknowledges.
"Whenever we remove them from the equation by using blockchain in a decentralized network, the parties involved have to become their own bank."
"What the role of entrepreneurs in the space will be is to make blockchain easy for everyone to use it to create a level of trust and security that right now is only being provided by these corporate entities."
Thinking smarter
Tennessee's new law is a moderate but significant step into the potential business applications of distributed ledger technology. It recognizes so-called "smart contracts," which aren't contracts in the traditional sense but are an automated series of "if, then" conditions carried out in a blockchain environment.
In smart contracts, when the programmed conditions are met, the transaction plays out to an end result, such as the transfer of assets. If one of the conditions is not met, the transaction is automatically locked.
It's a logical next step from digital signatures and digital records and is meant to give people confidence that when they're transacting and operating under Tennessee law, the terms of their smart contract will be enforced and recognized by the state.
Most states have, by now, begun an initiative or passed legislation dealing with some aspect of blockchain technology or cryptocurrencies, according to a survey by The Brookings Institution.
Arizona has also passed a law recognizing smart contracts. Colorado is looking into incorporating blockchain solutions into government functions, and West Virginia is testing a blockchain-based platform for mobile voting in upcoming primary elections.
Bitcoin fans rave, but understand it's still a risky business
Blockchain buzzwords
Learn more about blockchain and bitcoin
Some states have taken a wait-and-see stance as the technology develops and federal regulators assess how to classify and deal with some of its offshoots, most notably cryptocurrencies like bitcoins.
Other states have passed laws regulating blockchain-based cryptocurrencies in an effort to stem fraud and abuse from people issuing new digital currencies through initial coin offerings that amount to get-rich-quick schemes. The Securities and Exchange Commission is closely monitoring ICOs to determine whether new digital currencies constitute securities, which would trigger a host of regulatory requirements and costs.
Some have taken a more aggressive approach. Hoping to diversify its economy and attract tech companies, Wyoming has positioned itself as the most blockchain and cryptocurrency friendly state in the nation. It has passed laws that exempt cryptocurrency from state money transmitter licensing requirements, and exempt assets held in virtual currencies from property taxes.
To encourage companies to issue new cryptocurrencies, the state also exempts so-called "utility tokens," which operate somewhat like an iTunes gift card in that they give the holder access to a digital asset. If a new cryptocurrency is classified as a utility token rather than a security, it will not trigger securities regulations.
And since an increasing number of start-up companies, including some in Nashville, are issuing coins through ICOs to raise capital, any state that deems a new coin issue a utility token instead of a security will be an attractive place to register a business.
Bringing in the smartest mind
Competition for the brightest tech minds is especially keen in places like Chattanooga, which has invested heavily in citywide broadband and incentives for entrepreneurs, and Nashville, where much of the venture capital money is pouring into health care technology.
"A lot of these companies are truly mobile, especially in the startup stage," explains Gray Sasser, an attorney with Frost Brown Todd in Nashville who advises companies in the blockchain space.
"It's three or four people, a computer and a server, and they don't all have to be in the same location. To attract the business, you need to create more than just a regulatory framework. You're also needing to build that community that would be attractive to technologically-minded companies."
That's easier now that Nashville is on the radar of young people looking to leave larger cities.
Two years ago, the Nashville Blockchain Meetup group started with half a dozen people. Now it has 900 members, 200 of whom regularly attend the free and open monthly meetings. They include not only members of tech start-ups, but people from more established companies like Vanderbilt, Bridgestone and HCA.
"I'm so excited about what this is doing for Nashville, the community it's building," says Hashed Health's Ward, who hosts the Meetup.
"This is bringing the Health Care Council and the Tech Council together with the coding community … you look around and there's no other way all these people are coming together in the same room."
Ward affirms that Nashville's ascendance in the national eye is also helping to attract educated workers.
In March, Hashed Health developer Deon Summers traveled from Nashville to Washington, D.C., to participate in a blockchain code-a-thon.
There he met Zhenting (Zhen) Zhou, a developer from New York City. The two became friends while they built a blockchain-based system that rewards refugee families monetarily for completing tasks around mental health, legal support, education and health care.
They won first place (and 1 bitcoin.) Shortly after, Zhou moved to Nashville to work for Hashed Health.
"Now we have a brilliant programmer who left New York and came here. He said, 'I've heard Nashville's cool. I'll come to Nashville,'" Ward says.
"So, you've got to build some of your own but you've got to make something bright and shiny, and Nashville is doing its part in being a good place to come."
But in the end, what creates the conditions for growth and brings the tech sector to Tennessee may be the same business-friendly, low-tax policies that have always attracted more traditional companies. Tennessee's lack of income tax is an especially strong sell now that people can no longer deduct state income tax, Ward notes.
"The way that crypto assets are taxed, these are going to be big dollar decisions," he adds.
"It's cheaper for me to pick up my family and move to Tennessee, if I can find a good school in a good neighborhood to live in, than it would be to stay where I am. And so, Nashville, here we come."
Follow us on Facebook, Twitter & RSS:
Sign-Up For Our FREE email edition
Get the news first with our free weekly email
RECORD TOTALS
PROPERTY SALES 0 0 0
MORTGAGES 0 0 0
FORECLOSURE NOTICES 0 0 0
BUILDING PERMITS 0 0 0
BANKRUPTCIES 0 0 0
BUSINESS LICENSES 0 0 0
UTILITY CONNECTIONS 0 0 0
MARRIAGE LICENSES 0 0 0
and Updates.
Mayors launch task force to oppose minor league baseball contraction Jan 22 @ 5:52P
Trump suggests he may be open to Medicare, Social Security cuts Jan 22 @ 4:16P
US stocks flat as health authorities focus on China virus Jan 22 @ 4:15P
US to impose visas restrictions for pregnant women Jan 22 @ 3:25P
Vanderbilt University reaches deal on renewable energy push Jan 22 @ 3:23P
Trump: Travel ban expansion coming, nations aren't yet final Jan 22 @ 3:10P
Tesla passes $100 billion, teeing up big payout for Musk Jan 22 @ 3:08P
US official: China steals 'massive amounts' of data in West Jan 22 @ 3:08P
Fifth condemned Tennessee inmate opts for the electric chair Jan 22 @ 3:07P
Can equality pledges fix country music's gender problem? Jan 22 @ 3:07P
Home | Name & Property Research | Contact Us | Subscribe
Help | Customer Service
Copyright 1995 - 2020 by The Nashville Ledger - All Rights Reserved - Privacy Policy - About


text:
Online Learning Update
Google Teams Up With Udacity To Introduce A New Tech Entrepreneurship Nanodegree
Filed under: Online Learning News — Ray Schroeder @ 12:09 am
by Mir Juned Hussain, Tech Portal
Google, during its I/O 2015 developer conference in May had announced a partnership with Udacity to launch a six-course Android Development Nanodegree. The company wanted to allow developers to learn how to write apps for Google's mobile operating system. Surprisingly, these new Nanodegrees turned out to the most popular ones by Udacity, attracting more than 300,000 people to enrol in the courses. As a part of that initiative, Google has now introduced a new Nanodegree, which will consist of a Tech Entrepreneurship certificate, access to coaches, guidance on your project, help staying on track and career counseling. If all you want is the content, quizzes, and projects, all of that is available online for free at udacity.com/google.
http://thetechportal.in/2015/10/19/google-teams-up-with-udacity-introduces-tech-entrepreneur-nanodegree/
Comments Off on Google Teams Up With Udacity To Introduce A New Tech Entrepreneurship Nanodegree
~Blog data
Ray's Home Page
Blogs & Tweets by Ray
Recession Reality
Techno-News
Twitter Ray Schroeder
Email blog updates
Daily Email Updates-Free
RSS Feed by FeedBurner
Center for Online Learning, Research and Service
UIS Home
Online Learning News


text:
GTA Online Heists update will add daily objectives, new freemode activities
By Connor Sheridan
Turns out the Heist update for GTA Online (opens in new tab) will round out the multiplayer world with more than lucrative, multi-part mission lines. Rockstar Games has announced what to expect from the update heading out on March 10, including new daily objectives and freemode events.
It's plenty of fun to roam around, running over other players and getting into police chases in freemode, but you may have noticed that almost all the real action in GTA Online happens in Jobs. After the update, you'll get more calls from your contacts encouraging you to raise hell in public - Lester may want you to distract the cops in a certain area, or Trevor could ask you to shoot down one of his rivals' planes, for example.
Daily Objectives with give you more incentive to log in regularly with a rotating series of challenges. Stacking up a few days worth of challenges and completing them in one go could earn you up to $500,000 in in-game cash. You'll also be able to email friends regardless of what session they're in, and receive awards including exclusive clothes and car mods.
There's also even more reason to progress through all the Heists than just getting tons of cash: new Adversary modes will unlock as you clear each event, letting you play in several new themed competitions. Here're Rockstar's descriptions:
Come Out To Play: A team of three Runners just trying to make it home, and a team of Hunters are out for blood. Runners are well-armed but limited to movement by foot, while the opposition wield free-aim shotguns and ride motorbikes or ATVs. Hunters must stay on their bikes and have access to unlimited lives, while the Runners have just one life but all their weapons available to pick off the Hunters at will.
Siege Mentality: Up to four players stand their ground, outnumbered but not outgunned as they fight to survive against up to 6 determined attackers in a location defense mode, GTA style. Attackers have unlimited lives but fight only with sawn-off shotguns. Defenders have full use of all their weapons.
Hasta La Vista: The chase is on as Truckers in big rig cabs hunt down a team of Cyclists. The Cyclists' goal is simple: reach the final checkpoint without getting crushed under the wheels of the pursuing trucks. Without traditional weapons the Truckers must rely solely on their vehicles to crush the Cyclists. Meanwhile, the Cyclists must harness the maneuverability and acceleration of their bikes to evade the trucks, while keeping an eye over their shoulder. If one of the Cyclists reaches the checkpoint, the Cyclists win. If all Cyclists are terminated, the Truckers prevail.
Sounds like a serious boost for GTA 5 (opens in new tab)'s multiplayer component. I'm looking forward to trying it when the update arrives next week.
Connor Sheridan
I got a BA in journalism from Central Michigan University - though the best education I received there was from CM Life, its student-run newspaper. Long before that, I started pursuing my degree in video games by bugging my older brother to let me play Zelda on the Super Nintendo. I've previously been a news intern for GameSpot, a news writer for CVG, and now I'm a staff writer here at GamesRadar.


While Melbourne has become famous for its café culture and obscure hip laneway eateries, Sydney is still known for sandstone institutions with big water views (and even bigger bills).
But to focus on that would be to ignore the Harbour City's tastiest secret: epic burger joints.
Sure, in recent years, Sydney's burger 'market' has become over saturated (and not just with trans fats). Back in the day all you had was Mary's, Dan's Hong's Lotus cheeseburger and Chur Burger.
Now there are imitations and innovations of the classic American Burger™ as far as the eye can see (and the stomach rumble).
But before you go get lost in a mountain of Big Macs and Ben Bry's (not that there's anything wrong with either of those), we thought we'd come up with a list of the best burger joints in Sydney, to satisfy each and every craving.
Want something delicious, cheap and nasty? We've got you covered. After something a little more fancy? All good too. Or maybe you want a burger with a view? This list has got that as well, so do yourself a favour and add it to the bucket list for your next late lunch, or night out.
Where else in Sydney can you order a Trippin' Zeahorse burger with a Negroni on the side? No prizes for guessing where this culinary masterpiece is located. At Bonditony's Burger Joint, in the heart of the Eastern Suburbs (and by 'heart', we mean the beach), eating a burger is more than just a foodie experience—it's also about rock n' roll. With a background in the music biz, Tony came up with the idea to open a family friendly, punk rocky, down-to-earth burger joint in 2015—and the rest is history.
You're strolling down Oxford Street, having worked up an appetite at the local watering holes. After last weekend's antics in The Cross you're not sure you can stomach another World Bar teapot cocktail, greasy pepperoni pizza or ill-advised kebab. So now there's only one place left to turn: BL Burgers. From the 'classic cheese' to 'BL veg' and 'blame Canada' offerings there's enough variety here to satisfy you and your vegan Surrey Hills bae (if you're here on your own, treat yourself to the shoe-string fries—just for good measure).
The ultimate summer spot for you to enjoy the best view of the Pacific Ocean (this side of the bridge, anyway), Bondi's Icebergs Terrace also makes one mean burger. And if you're still peckish after, there's also Insalata, freshly shucked oysters and crispy fish sangers (along with a full cabinet of drinks), and much more on offer.
Forget it being the coolest place to party in Sydney since the lock out laws; Newtown has more to offer than Goon sack scolling undergrads and hipster cafes. Whether you're after a bacon and egg roll or something a little more serious, with its 'open diner' vibe and quality feeds Macelleria is the pick of the bunch.
Surrey Hills' finest 'dude food' establishment, Chur Burger is your go-to for OG beef burgers, marinated grilled chicken, lamb, fish and heaps more. Adding to the quality (but not pretentious) aesthetic are this joint's famous spiked milkshakes, which combine flavours like "apple crumble" and "fireball whisky." Basically, no night time escapade through the foodie capital of Sydney is complete without a trip to Chur.
Ume Burger is Bar Ume's fun-loving Barangaroo brother. With a slightly more "burger shop" vibe than Surrey Hills' Bar Ume, Ume Burger is a classic in and out burger joint. That said, it is located in waterfront Barangaroo, and crafted by Amber Road Design, so to say it's downmarket would be to go too far. Although they serve four mouth watering signature burgers (along with a Menchi version with crumbed pork belly, shredded cabbage, mustard, Japanese BBQ sauce and yuzu-kosho mayo) the place has become known for their pink, help-yourself soft-serve machine, which changes flavour each time you visit.
Internationally acclaimed chef Neil Perry offers Modern Australian cuisine in an ornate art deco room with a cocktail bar, which is the perfect venue for a pre or post lunch or dinner drink or casual bite to eat. With a no bookings policy, an excellent bar menu and a cocktail and wine list second to none, Rockpool Bar & Grill is ideal for life's impromptu moments.
After 8 years bettering Sydney's burger experience through its big brother, Pub Life Kitchen, Superior Burger launched in 2016 with a mission to serve humble burgers delivered with restaurant depth and principles. There's also Nashville hot chicken, beer battered potato scallops and fish tacos.
After refining his skills with Melbourne establishments like Grand Trailer Park Taverna and Royal Stacks Brunswick, burger nerd Dani Zeini brought his mouth-watering patties to Sydney in 2016—and Chatswood burger lovers haven't gone hungry since. As per all their outlets, Royal Stacks has a singular focus: burgers. And lots of 'em. Choices range from the classic Single Stack (beef patty with tomato, lettuce, pickles, cheddar and special sauce), to options like the Prince Harry (which adds horseradish, shallots and gherkin mayo), and The King (which chucks a huge mac 'n' cheese croquette into the works) for when you're feeling, as the Instagram kids say, 'extra'.
If slow food values with fast food service is your jam (relish?), then you'll feel right at home in any of the Burger Project's Sydney outlets. With offerings in Martin Place, Broadway and Circular Quay, Burger Project is the step up from Maccas that every young man must one day take. With a bright aesthetic and immediately satisfying, crunchy fare, the Burger Project is truly a burger joint worth getting your chin greasy for.


Hypnosis How Does It Work? There are some basic hypnotists' methods that are common practice and can be discussed without giving away any trade secrets.
They are that basically there are three must have situations for hypnosis to be successful: The person must want to be hypnotized, the person must believe that they can be hypnotized, the person must feel comfortable and relaxed about being hypnotized.
1. A fixed gaze or eye fixation. This is what most stage or movie hypnotists use when they wave a pocket watch in front of the subject. The hypnotist will try to get the subject to gaze intently on the object and tune out any other stimuli present. The hypnotist will then talk to the subject in low tones, with the intent of lulling the subject into a relaxed state. This method will not work on the majority of the population.
2. Rapid method. This is when the hypnotist will rapidly fire suggestions at the subject in a bid to overload the mind with lots of sudden commands. The purpose is to have the subject surrender his or her conscious control over tot he hypnotist. This is used most often when the subject is part of a stage performance.
3. Imagery and Progressive Relaxation. This is the method used most often by psychiatrists. The patient is coaxed into a relaxing state by a soothing and slow vocal pattern. The purpose is to completely relax the subject and to gain focus.
A test will be conducted to ascertain if the subject is open to suggestions by asking them to relax a limb, or to pretend that they are limp like a rag doll. The whole process of putting someone into a hypnotic state can take anywhere from a few moments to a little more than 30 minutes.
4. Rocking or Loss of Balance. Parents have been using this method for centuries without most being aware of the fact that they are hypnotizing their babies.
Many parents rock their babies to sleep in their arms using this type of rocking motion that puts the infant off balance. They drift into a trance-like sleep, so totally relaxed by the rocking that they totally relax and close their eyes. There are many ways that psychiatrists use hypnotism as a tool in treating their patients. One method for using hypnotism is "habit-control".
Hypnotic treatment is applied to a particular habit that is entrenched in a person's subconscious like overeating or smoking. The hypnotist suggests or reprograms the person's way of thinking concerning the habit by suggesting a negative response to the occurrence of the habit. When the person for instance lights up a cigarette they will immediately experience nausea.
Thus the negative response (the nausea) to the cigarette will transfer over time to the person feeling negative about smoking. This way the habit is easier to break because of he negative feeling associated with doing it. Habit-control hypnotism is used in many seminars, CD tapes and audio programs.


text:
Untapped Mailbag: Surfridge, the Abandoned Town Next to LAX Airport Is A Butterfly Preserve
Michelle Young 07/09/2013 Architecture, Los Angeles
Last week, we published an article about a town outside Paris that was abandoned after it ended up under the flight path of Charles de Gaulle Airport. We compared it to Surfridge, a town taken by eminent domain to enable expansion of LAX Airport. Alexandra Thorne, an Untapped Cities reader, contacted us with more information on why Surfridge hasn't been included on the master plan for the LAX Airport area. Turns out it's the habitat of the El Segundo Blue Butterfly, an endangered species. The city-run butterfly preserve at Surfridge has enabled a "remarkable comeback" of the species and is now the home for 125,000 of the butterflies.
Our own subsequent research yielded plans by the California Coastal Commission to restore 48 acres of Surfridge to its natural state, "part of a settlement of a lawsuit between LAX and surrounding cities over the airport's expansion plans," according to the LA Times.
Alexandra told us:
In the '80s, all plans to develop that land, which were passed by both city and airport officials, were voted down by the California Coastal Commission, whose estimates had the butterfly population at a mere 500 due to LAX development overtaking its only natural habitat. Concerns about the dwindling population of the rare butterfly were considered paramount.
Another fact Alexandra informed us about: Surfridge was established as a pure ethnicity, Caucasian-only community in the 1930's.
Want us to track down an obscure piece of history? Write to us at info@untappedcities.com or through our contact page.
LAX, Untapped Mailbag
The Lost 1964 World's Fair Subway Line and Cars
The WWII Radio Towers Atop Steiner Studios in the Brooklyn Navy Yard
Untapped Mailbag: What's the Restaurant on the Finale of Broad City?


text:
Sonja celebrates teaching milestone
North School's captains Lexie Smith (11) and Ethan Hocking (11) presented teacher Sonja McEvoy with a bouquet and certificate yesterday to honour her 30 years' service to the school. Ms McEvoy has seen many changes during her time at the school, but a few comforting constants have remained.
The school system has changed markedly in the last three decades, but for teacher Sonja McEvoy the best parts of the job have remained the same.
Ms McEvoy reached her 30-year milestone at North School yesterday, and was pleasantly surprised with the presentation of a bouquet of flowers and a certificate from students and staff.
She said she had seen several classroom transformations over the years, with schools moving from blackboards to whiteboards to electronic smartboards and computers.
There have been a few welcome constants in her job however, including the friendly and supportive community in the city's north, and the procession of smiling faces that passes through the school each year.
"There's been a lot of changes, from staff to surroundings, but it's still the same wonderful community - a nice North community that are very giving in their own special way," Ms McEvoy said.
"The highlight has just been the kids themselves, and how appreciative they can be of people who care about them."
"I've seen a lot of kids go through here and many have gone on and done a lot of good things for themselves.
"It's been a wonderful part of my life."
Ms McEvoy has worked at the school as both an infants and primary teacher, and is now assistant principal.
She said she will still be around to teach Broken Hill's children well into the future, with no plans for retirement on the horizon.


Jennifer Cadger is a lecturer in Rural Business Management for Year 1 students at SRUC in Edinburgh. Cultivate caught up with her to find out more about her role and what advice she has for those joining the Rural Business Management course.
How long have you lectured in Rural Business Management at SRUC?
Not long, I joined the RBM core team in September 2017.
What made you decide to become a lecturer?
Having worked in Marketing for several years in various roles I felt I was experienced (old?!) enough to encourage the next generation of students to develop their marketing and business knowledge. I also enjoy the autonomy and diversity of the role – a combination that I think is difficult to find.
How would you describe the Rural Business Management course?
Not your regular business management course! Students have access to a huge network of rural businesses which helps with sourcing examples for studies, placements, jobs after graduation and builds a wealth of practical/applied knowledge.
What makes it different to a normal Business course?
The small class sizes and 'open-door' environment. Students can engage in discussion and debate without feeling overwhelmed. They can develop stronger friendships with their peers and be part of a 'community'. Staff genuinely want to encourage and help students so pop into the office and ask questions!
What do you enjoy doing outside of SRUC?
Spending time with my family (I've got two young children, aged 4 and 9). I've also just started a postgraduate qualification in Tertiary and Higher Education, which is keeping me busy outside of work.
What do you like best about working at SRUC?
Every day is a school day for me at SRUC. I'm fairly naïve to the rural and agriculture sector (despite my step grandfather running his own pig farm that I did visit a few times when I was little!
Have there been any particular highlights e.g. study trips you've been on, stand out lectures, meeting new people, etc.
What you're looking forward to doing in your role over the next 6 months?
Embracing change. There's a huge amount of change on the horizon at SRUC, both at a strategic and tactical level. The momentum is building on all fronts and I think that will make for an interesting (and busy!) working environment over the next 6 months and beyond.
Words of wisdom to those on your course and to those thinking about joining the course.
Take every opportunity available to you at SRUC because you will always benefit from it – whether that's knowledge, contacts for the future or having fun with fellow students. There's plenty going on, make sure you get involved!


Hong Kong – Former Chief Secretary Carrie Lam "elected" to be next Chief Executive with 777 vote. Disappointments are among large group of netizens, but some are amused by the number of votes she got.
Hong Kong – It appeared as a set of repetitive text on the "Golden" online forum, the biggest in town, under the "creative section", where usually netizens post their silly ideas, or their parody works.
Hong Kong – Social media giant Facebook, yet again, causes online censorship fear in Hong Kong and the Chinese speaking world, after its system allegedly blocked series of "tankman" messages.
A rare scene in twitter, as complains and even F-bomb in a Hashtag form topped the trending topic Twitter chart in Hong Kong, as a top Chinese Mandarin landed in the SAR.
Hong Kong – A Fung Shui mistress with frequent media appearances in town said today, that she can "foresee" Her Majesty the Queen Elizabeth II is a very noble and wealthy lady.
Hong Kong – A song intended to viral within the Methodist College, Kowloon, suddenly turned into an online sensation.