Semi-automated ,surface ,mapping ,unsupervised learning ,classification ,Mercury ,Visible–Near-Infrared ,reflectance ,spectra
The sheer amount of data returned by scientific missions aimed at exploring the solar system and observing exoplanets in recent decades overwhelms classical methods to explore and discover important scientific aspects of the target body. As an example, the Mercury data return for Mariner 10 was less than 100 MB, while MESSENGER delivered about 23 TB. Future missions are expected to exceed this limit. In addition, there is a trend of increasing complexity in the data itself, e.g., going from the of Mariner-10 to the hyperspectral datasets expected from BepiColombo. This situation clearly indicates that some form of automated analysis would be beneficial, provided it is able to save time without a loss of the information content of the data.
Keeping the focus on hyperspectral remote sensing data, the typical approach for analysing this kind of data is to model the observed radiation with a forward radiative model1 or attempt to reproduce the observed radiation by setting up relevant samples in a laboratory setting using chemical and/or geomorphological context information.2 Complex forward models that are able to take into account the relevant physics are typically computationally intensive and difficult to use to investigate the very large parameter space covered by hyperspectral data. This consideration is even more relevant for laboratory investigations : physical simulation needs the target to be physically fabricated, hence more and and more parameters means more experiments and more time. Models need computational power to be calculated in a reasonable amount of time, but could be distributed on several machines to overcome this limitation. This workaround is not effective for laboratory experiment, because most only few places meets of the environment needed for space sample simulation, like high-vacuum, -temperature, -radiation and so on.
Without a way to efficiently and rapidly explore large amounts of complex data, it is likely that valuable information will be missed in large hyperspectral data sets.
Geological maps are the gold standard for remote planetary surface studies, but producing them is an extremely time-consuming task. This process can suffer from user bias and typically only uses a few data points (e.g., 3-channel images) to describe different units. For example,3 mapped the distribution and extent of major terrain types of Mercury using MESSENGER Mercury Dual Imaging System (MDIS) camera observations of Mercury. While the camera has 11 spectral bands, the maps typically used for the terrain differentiation are RGB, where 3 representative spectral bands are mapped onto the three image color channels.
Geomorphological maps take in account additional features like surface roughness and crater density as a proxy for the age, where the correlation between age and crater density are derived from models.4 Automated techniques are becoming more common in planetary science applications, as this books testifies, and the aim of this chapter is to illustrate how to apply unsupervised learning techniques to remote sensing data. This approach requires minimal user interaction and yields scientifically interesting products like classification maps that can be directly compared with geomorphological maps and models. We present an analysis of spectral reflectance data of Mercury’s surface collected by the Mercury Atmospheric and Surface Composition Spectrometer (MASCS) instrument during orbital observations of the NASA MESSENGER mission between 2011 and 2015.5 MASCS is a three sensor point spectrometer with a spectral coverage from 200 nm to 1450 nm. After a brief overview of the instrument and its significance for the investigation of Mercury (section 2), we will illustrate how we extract and resample the data to a format useful for our ML application (section 3). Then we show how to compress the data (section 4.1), how to project them to a lower number of dimensions (section 4.2), and finally, how to group “similar” data points together to discover salient spectral classes and their distribution on the surface. We conclude in section 4.4 by providing a basic comparison of the result of the discovered spectral class distribution with maps of the surface of Mercury obtained using classical methods, in order to provide a first assessment of the machine learning techniques presented here.
Surface mineralogy and composition are important indicators of the past of a planetary body, since they provide hints about the processes that formed and altered the crust, which is largely the result of the interior evolution. For example, the possibility of identifying specific mineral assemblage like metamorphic rocks, which are known to form in specific pressure and temperature conditions, would provide indications on the physical processes occurring in the subsurface that produced those rocks and later transported the rocks to the surface.6 Similarly, observations of hydrated minerals can be interpreted as indicating the possible past presence of water, as in the case of Mars.7
While some investigations have been published on Mercury’s surface mineralogy,8 its link to the endogenous (e.g., mantle convection) and exogenous (e.g., impacts) processes that operated during the history of the planet is still difficult to elucidate.9 A relevant example is the geological features known as hollows, discovered on the surface of Mercury in MESSENGER data. Hollows are rimless depressions with flat floors, surrounded by halos of high-albedo material, and typically found in clusters.10 Given this evidence, their formation mechanism likely includes the loss of volatile material through one or more processes such as sublimation, space weathering, outgassing, or pyroclastic flow. Hollows are associated with a particular spectral signature in MESSENGER’s MDIS camera,11 but a specific spectral signature in spectrometer data could not be identified due to the coarse spatial resolution of the spectrometer. Overall, the only clear inference based on VNIR spectra obtained by the MASCS instrument is that Mercury’s surface shows little variation, displaying no distinct spectral features except for the possible indication of sulfide mineralogy within the hollows.12
MASCS consists of a small Cassegrain telescope with an effective focal length of 257 mm and a 50-mm aperture that simultaneously feeds an UltraViolet and Visible Spectrometer (UVVS) and a Visible and InfraRed Spectrograph (VIRS) channel. VIRS is a fixed concave grating spectrograph with a focal length of 210 mm, equipped with a beam splitter that simultaneously disperses the light onto a 512-element sensor (VIS, 300–1050 nm) and a 256-element infrared sensor array (NIR, 850–1450 nm). Data obtained by MASCS covers almost the entire surface of Mercury. The spatial resolution is highly latitude dependent due to the very elliptical orbit of the spacecraft, but a reference value ∼ 5 km. This low spatial resolution is a trade-off for higher spectral resolution and more spectral channels compared to the imaging instruments (i.e., the MDIS).
The NIR sensor is characterized by 3 – 5 times lower signal-to-noise ratios (SNRs) than the VIS detector and does not add significant information to the VIS sensor in our tests. NIR measurement cann be linked and corrected to match corresponding VIS measurements following.13 The biggest obstacle is that the the most accurate photometric corrections is only available for the VIS channel.14 We then analysed only data from VIS channel, that is enough for the sake of illustrating unsupervised learning techniques.
In what follows, we use “feature” to refer to a single spectral reflectance value in a given spectrum and refer to the spectrum as an “observation”. An observation is taken on a particular area of the surface of Mercury at a given time and thus with a given illumination condition. MASCS data are obtained as a collection of binary files following the PDS3 standard.15 We need to preprocess these to be represented as a matrix of shape [N×M] where M is the number of features and N is the number of observations before they can be used as input to typical machine learning algorithms. A spectrum can be represented as a vector, with the single spectral channels being its components, i.e., x̂ = (x1,...,x512), for the case where the spectrum x̂ has 512 components. The entire MASCS dataset comprises about 5 million spectra, each with 512 channels. The coverage is not homogeneous across Mercury’s surface, as illustrated in Figure 1. In this section we describe how to create a homogeneous gridded representation of the observations across the entire surface so that we can apply our clustering algorithm to the entire surface, as shown in Figure 2.
A typical workflow for doing a planetary science analysis starts with the definition of a number of Regions Of Interests (ROIs), followed by a search for all data points that fall within these ROIs. This approach facilitates the extraction of spectral signatures that are specific to user-defined geological units in order to explore their properties in the context of different ROIs. For this chapter, we developed a workflow that starts by extracting the data from the original files using the GDAL16 python binding. We then organized them in a PostgreSQL relational database 17, with the PostGIS spatial extension18. The database is currently hosted at the DLR in Berlin.
First, the whole dataset of ∼ 5 million spectra is resampled to a planet-wide rectangular grid of 1∘ × 1∘ in the latitudinal band between ± 80∘. The cell longitudinal size varies between ∼ 40 km at the equator to a minimum of ∼ 10 km at ± 80∘. Thus, the area spanned by each grid cell depends on the latitude. However, the same is true for the acquisition process, where higher spatial resolution is reached near the equator and lower resolution at the poles. Next, we resampled the data in the spectral dimension to a common wavelength range19 from 260 nm to 1052 nm with a 4 nm resolution (2 nm spectral sampling), resulting in 396 spectral channels. This approach slightly oversamples the original 4.77 nm spectral resolution and removes some points from the original 200-1050 nm range. The resulting data matrix is expressed in tabular form, with each row representing a single grid cell or pixel on the surface. The elements of each row are the spectral reflectance values from the VIS instrument at 396 (resampled) wavelengths. The dataset now has dimension [N×M] where N is the number of grid cells (360 × 180 = 64, 800) and M is the number of spectral features (396). Due to the incomplete coverage and data filtering, some grid cells are empty. After removing these empty cells, the size of the dataset is [55399 × 396]. As an example, Figure 2 shows the distribution of the normalized reflectance at a fixed wavelength (700 nm).
We used a recent dataset that had large-scale photometric corrections20 and thus was almost free from observation geometry effects. However, extreme geometry are still present and are typically associated with high noise and some residual instrumental effects. Based on our empirical tests, we filtered out observations with an emission/incidence angle ≥80∘. We also calculated the median value per wavelength and per cell grid when constructing the global hyperspectral data cube and filtered out observations falling under the 2nd percentile and above 99.9th percentile to clean some residual geometry effects. With this approach we create an effective noise filter while retaining enough observations to be able to analyse the entirety of the surface of the planet.
One way to discover salient patterns in a large set of multidimensional data is to perform dimensionality reduction. Two popular techniques for dimensionality reduction are Independent Component Analysis (ICA) and Principal Component Analysis (PCA).
PCA try to find a reduced-rank representation of the data and seeks for that best explains the variability of the data.
ICA is a case of blind source separation techniques and assumes that the observations are non-Gaussian signals and statistically independent from each other.21 ICA aims to find a set of new basis vectors as Principal Component Analysis, but with different assumptions and significance of the new basis. ICA search a basis where each vector is an independent component: if one think of a mix of superposed audio signals, the ICA basis will return a vector for each independent signal, like in the Blind Signal Separation techniques. ICA helps to find a representation of the data as independent sub-elements.
In practical terms, PCA helps to compress data and ICA helps to separate data.
The data cube obtained from previous section is then decomposed with ICA, trying to separate multivariate signal into additive sub-components.
We represent the input data as x̂ = (x̂1,...,x̂n)T, where x̂i is a vector of 396 spectral reflectance values for a given observation. ICA tries to find a linear transformation W so that ŝ = Wx̂, where ŝ = (ŝ1,...,ŝk)T is a vector of maximally independent components and k ≤ n. W is also called the mixing matrix and has dimension [f×k] = [ (data dimension)× (number of ICA independent sources)]. The original sources ŝ can be recovered by multiplying the observed signals x̂ with the inverse of the mixing matrix W = A−1, also known as the unmixing matrix.
The goal is to find a number of independent components that can somehow be connected to geologic patterns observed on the surface. There is no “true number” of independent components based on the surface geology, so to choose k we use a reconstruction error threshold that represents the noise in the data. This value is chosen from the residual standard deviation when calculating the data median for each pixel in the surface 1∘ × 1∘ grid (see 3) and represents the sub-pixel variation of the data.
The independent vectors s are function of the number k of component and by increasing it the reconstruction error decrease. Figure 3 shows how the reconstruction error decreases wiht additional components and that the condition ||x − s(n)|| < 0.0015 is true for n ≥ 4. The final result is a compression of the data from [55399 × 396] to [55399 × 4].
In this application it is interesting to visualize the mixing weight matrix W, i.e., the linear operator that maps independent sources to the data x̂. The weight coefficient for each component s represents how close each data point is to the corresponding independent component. Figure 5 shows the weight coefficients maps, illustrating the spatial distribution of each component. Components 1 and 2 show well-defined clusters enriched (red) and depleted (blue) in the corresponding component. For components 0 and 3, the spatial distribution does not display any particular structure. This could be the result of some residual instrumental effects that introduce variance in the data.
In the previous section, we reduced the entire dataset to a representation where each pixel in the surface grid was represented by 4 features computed using ICA instead of 396 spectral values (Figure 5). Before performing clustering on the dataset, we further reduced the dimensionality using manifold learning techniques. While it is technically possible to use manifold learning techniques to reduce the dimensionality without the ICA step, we applied ICA first because manifold learning algorithms do not computationally perform well for high-dimensional data. This is why they are usually used after a data compression step.
A number of supervised and unsupervised linear dimensionality reduction techniques exist, including but not limited to: Isomap, Locally Linear Embedding (LLE), Hessian Eigenmapping, t-distributed Stochastic Neighbor Embedding (t-SNE), and Uniform Manifold Approximation and Projection (UMAP). See, e.g., the following review papers and the references therein :.22 The linear algorithms most important aspect is that their results are be easier to interpret than non-linear algorithms, but by definition they could miss important non-linear structures in the data.
Manifold Learning methods are a class of non-linear dimensionality reduction techniques. They are based on the idea that the intrinsic dimensionality of many data sets is actually much lower than its actual dimensionality.
The linear dimensionality reduction techniques can be considered also dimensionality reduction techniques, because this terms embraces a broader set of algorithms. If we look at ICA and the Manifold Learning methods as a black box, they both compress input data. Their underlying assumption, the steps to find the lower dimension representation and the insight we gain from them are different, as we will see below.
The typical manifold learning problem is unsupervised: it learns the high-dimensional structure of the data from the data itself, without the use of predetermined classes.23
UMAP and t-SNE are popular methods for manifold learning. At its core, t-SNE projects high-dimensional data in a space of lower dimensions. t-SNE initialization aims to model the probability distribution that represents similarities between neighbors (data points). It starts with a small random Gaussian distribution and for the first iterations the input probabilities are multiplied by an integer factor to ‘exaggerate’ the distribution. t-SNE converts similarities between data points to joint probabilities then tries to minimize the divergence between the joint probabilities of the low-dimensional embedding and the high-dimensional data. Original data points that are similar are modeled by nearby points in the low dimensional embedding. Dissimilar data points are modeled by distant points with high probability in the embedded space.
Compared to other techniques, t-SNE is particularly sensitive to local structure and can reveal the structure at many scales on a single map for data that lie in different manifolds or clusters. While linear methods such as Isomap and LLE unfold a single continuous low dimensional manifold, t-SNE will tend to extract clustered local groups of samples, since it focuses on the local structure of the data. For a complete overview of t-SNE we refer the reader to24 and the references therein.
While powerful, t-SNE is extremely computationally expensive and can take several hours on million-sample data sets where PCA will take seconds to minutes. In addition, the downside of using a random initialization is repeatability: even if you use a fixed seed, there is no guarantee that the final results will be the same. This means that t-SNE can produce results with different initialization on the same data, so a good practice is to run t-SNE for multiple random seeds for the same dataset. Thus, we chose to apply UMAP25 since this method offers a number of advantages over t-SNE, most notably increased speed with preservation of the global data structure.
We will give here an high level description of UMAP, trying not to make the description too complicated and not to fall into areas beyond this book. This can leave room for ambiguity and errors that are only our fault due to too much simplification of a complex topic. A rigorous mathematical background could be fund in26 and nice visualisation in the https://umap-learn.readthedocs.io/en/latest/how_umap_works.html27.
UMAP uses local manifold approximations, represent those with a local fuzzy simplicial set representations and uses their union to construct a topological representation of the high dimensional data. A simplicial complex is a set composed of points, line segments, triangles, and their n-dimensional counterparts. Fuzzy topology means that being in an open set is no longer a binary yes or no, but instead a fuzzy value between zero and one. The probability of being in a ball of a given radius for points will decay moving away from the center of the ball. Given some low dimensional representation of the data, a similar process can be used to construct an equivalent topological representation in the other direction (low to higher dimension). UMAP then searches for a low dimensional projection of the data that has the closest possible equivalent fuzzy topological structure to the high dimensional one.
UMAP follows the philosophy of t-SNE, but has a number of improvements such a different cost function and the absence of normalization of high- and low-dimensional probabilities. Further details can be found in the original paper,,28 and its reference python implementation,.29
The two main hyperparameters controlling the representation learned by UMAP are n_neighbors and min_dist30. With n_neighbors one can adjust the sensitivity to local or global structures in the data by constraining the size of the local neighborhood. Low values correspond to a focus on very local structures, possibly losing the big picture, while large values, corresponding to larger neighborhoods, may miss the fine structure. The best value to choose depends on the particular data structure and the desired range (local vs. global) the application is required to probe. Values can go from 0 (local) to the size of the data (global). min_dist regulates how points are packed together, providing the minimum distance apart that points are allowed to be in the low dimensional representation. Low values will result in more dense embeddings while larger values will result in more sparse embeddings.
Figure 6 shows the density pair plots of the four ICA weight coefficients. This shows that the data manifold is a slightly asymmetric 4D cloud, with most of the data concentrated in the center. Figure 7 shows the UMAP density plot on the ICA weight coefficients for various combinations of the two hyperparameters described above. The projected data topology follow the 4D manifold, with a central core of high density observations and a rarefied peripheral region. We chose to use n_neighbors = 4000 and min_dist = 0.99. In our particular application because local structures are not apparent at any level, so the only significant structure is the overall shape of the low dimension representation and how where the data points lies relative to each other.
After using UMAP to further reduce the representation of the dataset compressed using ICA, the final dimensionality of the dataset is [55399 × 2].
After reducing the dimensionality of the data, our final goal is to identify surface regions with similar spectral properties that we can use to make geologic interpretations. As described in the Introduction, this is because geologic surfaces are generally classified into a few classes which are related with a geological taxonomy.
Cluster analysis comprises a series of techniques that attempt to group similar observations in groups or clusters. The idea is that observations belonging to a cluster are more similar to each other than to those in other clusters. Before clustering the data, we first standardized the data by subtracting the mean and scaling them to unit variance. This is a standard and often necessary step for any machine learning algorithm.
K-means clustering is a very popular clustering algorithm due to its computational efficiency and its many available implementations. K-means is a vector quantization technique, where an observation belongs to the cluster with the nearest mean (cluster center or cluster centroid), serving as a prototype of the cluster. K-means assumes that the variance of the distribution of each feature is spherical, that all features have similar variance, and that the prior probability for all k clusters is the same, i.e., each cluster has roughly equal numbers of observations.
Another family of clustering algorithms is known as hierarchical clustering algorithms, which build nested clusters by merging or splitting them successively. Hierarchical agglomerative clustering merges closer points together, irrespective of the final cluster class balance. The hierarchy of clusters is represented as a dendrogram as in Figure 11. The final tree has one unique cluster comprising all the samples at the root and clusters with only one sample at the leaves (bottom of the tree). The branch lengths represent the distance between the child clusters. Small gaps connect more similar clusters and big gaps connect more different clusters. The cluster distance is computed as the maximum Euclidean distance distances between all observations of the two clusters.
We choose the agglomerative clustering algorithm because it could be easily adapt to use different distance metrics and directly produce the tree like representation of the whole clusterisation (the dendrogram). It is more computationally intensive than the K-mean, but the latter gives directly a way to judge the correct number of cluster.
We used the reconstruction error threshold to choose the value of k, i.e., the number of clusters. Interested readers could explore other methods like the silhouette score31 calculated using the mean intra-cluster distance and the mean nearest-cluster distance for each sample. Figures 8 and 9 show the resulting cluster assignments in the UMAP embedded space when using aggolomerative clustering and K-means clustering with k = 3 clusters.
The clustering methods we described are just a few of the available clustering techniques and methdos may have better results for different datasets.32 For example, when dealing with data containing clusters of similar density interleaved with low density zones (like clusters of data in some dimension with added noise), Density Based Spatial Clustering of Applications with Noise (DBSCAN) may give better results. DBSCAN separates core samples of high density regions and expands clusters from them.
The result of our analysis is a set of cluster maps such as in Fig.12. These maps can be directly compared with with models (i.e. surface maximum temperature, roughness or age ) and with expert-generated maps that are based on different methods of analysis described in the Introduction. Fig.13 shows the finer clusters defined when splitting the data in 12 clusters. The structure is essentially the same as the 3-cluster case, indicating that this reduction does not appreciably affect the information content gained from the cluster map. The spatial distribution of the red cluster in the north compares favourably with the location of younger volcanic smooth plains plotted in Figure 15. These plains are widespread on Mercury, but are more concentrated in the north and in the surroundings of the Caloris impact basin (30.5∘N 189.8∘W) and are most likely of volcanic origin. The smooth plains are younger than the Caloris basin, as indicated by the lower crater densities in those regions.35 The basin floor is filled by geologically distinct plains implanted after the impact at the origin of the basin itself.
The result of our works is the division of the surface in three classes or clusters, that capture some inherent properties of Mercury in the VNIR range as measured by MASCS instrument.
The red clusters (fig.12) are concentrated outside the hot poles, hinting at the possible role that thermal processing could play in modifying the spectra of the surface.
The representative spectra for those classes differs mostly for the spectral tilt, which is the ratio between longer (redder) and shorter (bluer) wavelengths, as shown in Figure 10. It is important to stress that this is a general property of Mercury MASCS spectra. They do not show any significant absorption bands, thus it is difficult to match the spectra with known mineral assemblages. This is even more pronounced taking the average of a great number of spectra, washing out single spectral characteristic. This is not always the case, i.e.36 did found spectral classes on Mars and linked them to terrestrial basaltic and an andesitic composition, roughly related to the Martian dichotomy and older/younger surfaces.
In the case of Mercury, several factors are in play.
Mercury’s 3:2 spin–orbit resonance with the Sun creates the characteristic surface temperature distribution shown in Figure 14, which maps the maximum temperature reached at each point of the surface, based solely on solar irradiation. There are two hot poles around 0∘ and 180∘.
Thermal processing is known to tilt spectra to higher reddening, i.e., steeper spectra.37
Solar wind irradiation also concurs to redden the spectra, even though the literature on this topic focused mostly on asteroids with high-Fe content, while Mercury’s surface is extremely low in iron.38 Mercury reflectance spectra are also extremely dark and amorphous carbon has been proposed as darkening agent.39
To summarize, dimensionality reduction, manifold learning, and cluster analysis techniques are powerful tools to explore large sets of uncategorized planetary data. The workflow we presented could be easily extended to include additional instrument data, for example including data on the same geographical locations of chemical composition extracted from the X-Ray Spectrometer (XRS).40 While we focused only on reflectance data in this study, the technique of data fusion could further promote the discovery of scientifically-interesting patterns in the data, thus helping to understand complex physical mechanisms that could not be revealed by data coming from a single instrument.
The code and data used in this work is available as python jupyter notebook on the github public repository MESSENGER-Mercury-Surface-Cassification-Unsupervised_DLR41 funded under the European Union’s Horizon 2020 research and innovation programme grant agreement No 871149. The Working Package "Machine Learning Solutions for Data Analysis and Exploitation in Planetary Science" aims to develop and implement an ambitious sustainable ML toolset, tailored for the needs of the planetary science community by analysing a representative set of scientific cases.
Like Hapke, as in Hamilton, McSween, and Hapke, “Mineralogy of Martian Atmospheric Dust Inferred from Thermal Infrared Spectra of Aerosols.”↩
E.g., Helbert et al., “Visible and Near-Infrared Reflectance Spectra of Thermally Processed Synthetic Sulfides as a Potential Analog for the Hollow Forming Materials on Mercury.”↩
Denevi et al., “MESSENGER Global Color Observations.”↩
E.g., Bland, “Crater Counting”; Kerr, “Who Can Read the Martian Clock?”↩
McClintock and Lankton, “The Mercury Atmospheric and Surface Composition Spectrometer for the MESSENGER Mission.”↩
E.g., Namur and Charlier, “Silicate Mineralogy at the Surface of Mercury.”↩
Meslin et al., “Soil Diversity and Hydration as Observed by ChemCam at Gale Crater, Mars.”↩
E.g., E. Vander Kaaden et al., “Geochemistry, Mineralogy, and Petrology of Boninitic and Komatiitic Rocks on the Mercurian Surface”; Namur and Charlier, “Silicate Mineralogy at the Surface of Mercury”; Vilas et al., “Mineralogical Indicators of Mercury’s Hollows Composition in MESSENGER Color Observations”; Sprague et al., “Spectral Emissivity Measurements of Mercury’s Surface Indicate Mg- and Ca-Rich Mineralogy, K-Spar, Na-Rich Plagioclase, Rutile, with Possible Perovskite, and Garnet.”↩
E.g., Padovan et al., “Impact-Induced Changes in Source Depth and Volume of Magmatism on Mercury and Their Observational Signatures.”↩
Blewett et al., “Hollows on Mercury.”↩
Vilas et al., “Mineralogical Indicators of Mercury’s Hollows Composition in MESSENGER Color Observations.”↩
Ibid.↩
However, see Besse, Doressoundiram, and Benkhoff, “Spectroscopic Properties of Explosive Volcanism Within the Caloris Basin with MESSENGER Observations” for a successful VIS/NIR cross correction.↩
See. Domingue et al., “Analysis of the MESSENGER MASCS Photometric Targets Part I”; Domingue et al., “Analysis of the MESSENGER MASCS Photometric Targets Part II.”↩
NASA, “PDS.”↩
We found a GDAL bug when reading 8 bytes real values that is solved for version ≥2.3.0 after our report to the developer. See https://trac.osgeo.org/gdal/wiki/Release/2.3.0-News and use this version or higher when manipulating MASCS data.↩
PostgreSQL is a relational database management that controls the creation, integrity, maintenance and use of a database↩
PostGIS adds support for geographic objects in geographic information system and extends the database language with functions to create and manipulate geographic objects. PostGIS follows the Simple Features for SQL specification from the Open Geospatial Consortium (OGC).↩
MASCS VIS data have different wavelength sampling and part of the global Mercury campaign had different spectral binning.↩
Domingue et al., “Analysis of the MESSENGER MASCS Photometric Targets Part I”; Domingue et al., “Analysis of the MESSENGER MASCS Photometric Targets Part II.”↩
Hastie, Tibshirani, and Friedman, The Elements of Statistical Learning; Hyvärinen and Oja, “Independent Component Analysis.”↩
Tenenbaum, Silva, and Langford, “A Global Geometric Framework for Nonlinear Dimensionality Reduction”; Roweis and Saul, “Nonlinear Dimensionality Reduction by Locally Linear Embedding”; Donoho and Grimes, “Hessian Eigenmaps”; Maaten and Hinton, “Visualizing Data Using t-SNE”; McInnes, Healy, and Melville, “UMAP.”↩
Lee and Verleysen, Nonlinear Dimensionality Reduction.↩
Roweis and Saul, “Nonlinear Dimensionality Reduction by Locally Linear Embedding.”↩
McInnes, Healy, and Melville, “UMAP.”↩
Ibid.↩
https://umap-learn.readthedocs.io/en/latest/how_umap_works.html↩
McInnes, Healy, and Melville, “UMAP.”↩
McInnes, “UMAP.”↩
The interactive tutorial "Understanding UMAP" give some insight in how the hyperparameters influence UMAP. See (Coenen and Pearce, “Understanding UMAP”) and https://pair-code.github.io/understanding-346umap↩
see for example "Selecting the number of clusters with silhouette analysis on KMeans clustering" https://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_silhouette_analysis.html↩
Rui Xu and Wunsch, “Survey of Clustering Algorithms.”↩
Vasavada, “Near-Surface Temperatures on Mercury and the Moon and the Stability of Polar Ice Deposits.”↩
Denevi et al., “The Distribution and Origin of Smooth Plains on Mercury.”↩
Ibid.↩
Bandfield, Hamilton, and Christensen, “A Global View of Martian Surface Compositions from MGS-TES.”↩
Maturilli et al., “Komatiites as Mercury Surface Analogues.”↩
Nittler et al., “Global Major-Element Maps of Mercury from Four Years of MESSENGER X-Ray Spectrometer Observations.”↩
Peplowski et al., “Remote Sensing Evidence for an Ancient Carbon-Bearing Crust on Mercury.”↩
Nittler et al., “The Major-Element Composition of Mercury’s Surface from MESSENGER X-Ray Spectrometry”; Nittler et al., “Global Major-Element Maps of Mercury from Four Years of MESSENGER X-Ray Spectrometer Observations.”↩
https://github.com/epn-ml/MESSENGER-Mercury-Surface-Cassification-Unsupervised_DLR↩


You can use d-on-model-complete to execute an expression when the model event is fired. Event when the value is equal.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Hypergraph | |
|---|---|
| edu.uci.ics.jung.algorithms.filters | Filtering mechanisms that produce subgraphs of an original graph. |
| edu.uci.ics.jung.algorithms.scoring | Mechanisms for assigning values (denoting significance, influence, centrality, etc.) to graph elements based on topological properties. |
| edu.uci.ics.jung.algorithms.scoring.util | Utility functions for assigning scores to graph elements. |
| edu.uci.ics.jung.algorithms.shortestpath | Provides interfaces and classes for calculating (geodesic) distances and shortest paths. |
| edu.uci.ics.jung.algorithms.transformation | Mechanisms for graph transformation. |
| edu.uci.ics.jung.graph | Interfaces for the JUNG graph types, and some representative implementations. |
| edu.uci.ics.jung.io | Interfaces and classes for reading and writing graphs in various (file) formats. |
| edu.uci.ics.jung.io.graphml | |
| edu.uci.ics.jung.io.graphml.parser |
| Uses of Hypergraph in edu.uci.ics.jung.algorithms.filters |
|---|
| Methods in edu.uci.ics.jung.algorithms.filters with type parameters of type Hypergraph | ||
|---|---|---|
static
|
FilterUtils.createAllInducedSubgraphs(Collection<? extends Collection<V>> vertex_collections,
G graph)
Creates the induced subgraphs of graph associated with each
element of vertex_collections . |
|
static
|
FilterUtils.createInducedSubgraph(Collection<V> vertices,
G graph)
Creates the induced subgraph from graph whose vertex set
is equal to vertices . |
| Uses of Hypergraph in edu.uci.ics.jung.algorithms.scoring |
|---|
| Fields in edu.uci.ics.jung.algorithms.scoring declared as Hypergraph | |
|---|---|
protected Hypergraph<V,E> |
AbstractIterativeScorer.graph
The graph on which the calculations are to be made. |
protected Hypergraph<V,?> |
DegreeScorer.graph
The graph for which scores are to be generated. |
protected Hypergraph<V,E> |
DistanceCentralityScorer.graph
The graph on which the vertex scores are to be calculated. |
| Constructors in edu.uci.ics.jung.algorithms.scoring with parameters of type Hypergraph | |
|---|---|
AbstractIterativeScorer(Hypergraph<V,E> g)
Creates an instance for the specified graph g . |
|
AbstractIterativeScorer(Hypergraph<V,E> g,
Creates an instance for the specified graph and edge weights. |
|
AbstractIterativeScorerWithPriors(Hypergraph<V,E> g,
Creates an instance for the specified graph, edge weights, vertex priors, and jump probability. |
|
AbstractIterativeScorerWithPriors(Hypergraph<V,E> g,
Creates an instance for the specified graph, vertex priors, and jump probability, with edge weights specified by the subclass. |
|
BarycenterScorer(Hypergraph<V,E> graph)
Creates an instance with the specified graph. |
|
BarycenterScorer(Hypergraph<V,E> graph,
Distance<V> distance)
Creates an instance with the specified graph and distance metric. |
|
ClosenessCentrality(Hypergraph<V,E> graph)
Creates an instance which measures distance on the graph without edge weights. |
|
ClosenessCentrality(Hypergraph<V,E> graph,
Distance<V> distance)
Creates an instance using the specified vertex/vertex distance metric. |
|
DegreeScorer(Hypergraph<V,?> graph)
Creates an instance for the specified graph. |
|
DistanceCentralityScorer(Hypergraph<V,E> graph,
boolean averaging)
Equivalent to this(graph, averaging, true, true) . |
|
DistanceCentralityScorer(Hypergraph<V,E> graph,
boolean averaging,
boolean ignore_missing,
boolean ignore_self_distances)
Creates an instance with the specified graph and averaging behavior whose vertex distances are calculated on the unweighted graph. |
|
DistanceCentralityScorer(Hypergraph<V,E> graph,
Distance<V> distance,
boolean averaging)
Equivalent to this(graph, distance, averaging, true, true) . |
|
DistanceCentralityScorer(Hypergraph<V,E> graph,
Distance<V> distance,
boolean averaging,
boolean ignore_missing,
boolean ignore_self_distances)
Creates an instance with the specified graph, distance metric, and averaging behavior. |
|
EigenvectorCentrality(Hypergraph<V,E> graph)
Creates an instance with the specified graph and default edge weights. |
|
EigenvectorCentrality(Hypergraph<V,E> graph,
Creates an instance with the specified graph and edge weights. |
|
HITSWithPriors(Hypergraph<V,E> g,
Creates an instance for the specified graph, edge weights, vertex prior probabilities, and random jump probability (alpha). |
|
HITSWithPriors(Hypergraph<V,E> g,
Creates an instance for the specified graph, vertex priors, and random jump probability (alpha). |
|
KStepMarkov(Hypergraph<V,E> graph,
Creates an instance based on the specified graph, edge weights, vertex priors (initial scores), and number of steps to take. |
|
KStepMarkov(Hypergraph<V,E> graph,
Creates an instance based on the specified graph, vertex priors (initial scores), and number of steps to take. |
|
KStepMarkov(Hypergraph<V,E> graph,
int steps)
Creates an instance based on the specified graph and number of steps to take. |
|
PageRank(Hypergraph<V,E> graph,
Creates an instance for the specified graph, edge weights, and random jump probability. |
|
PageRank(Hypergraph<V,E> graph,
double alpha)
Creates an instance for the specified graph and random jump probability; the probability of following any outgoing edge from a given vertex is the same. |
|
PageRankWithPriors(Hypergraph<V,E> graph,
Creates an instance with the specified graph, edge weights, vertex priors, and 'random jump' probability (alpha). |
|
PageRankWithPriors(Hypergraph<V,E> graph,
Creates an instance with the specified graph, vertex priors, and 'random jump' probability (alpha). |
|
VoltageScorer(Hypergraph<V,E> g,
Creates an instance with the specified graph, edge weights, source vertices (each of whose 'voltages' are tied to 1), and sinks. |
|
VoltageScorer(Hypergraph<V,E> g,
Creates an instance with the specified graph, edge weights, source voltages, and sinks. |
|
VoltageScorer(Hypergraph<V,E> g,
Creates an instance with the specified graph, edge weights, source, and sink. |
|
VoltageScorer(Hypergraph<V,E> g,
Collection<V> sources,
Collection<V> sinks)
Creates an instance with the specified graph, source vertices (each of whose 'voltages' are tied to 1), and sinks. |
|
VoltageScorer(Hypergraph<V,E> g,
Map<V,? extends Number> source_voltages,
Collection<V> sinks)
Creates an instance with the specified graph, source voltages, and sinks. |
|
VoltageScorer(Hypergraph<V,E> g,
V source,
V sink)
Creates an instance with the specified graph, edge weights, source, and sink. |
| Uses of Hypergraph in edu.uci.ics.jung.algorithms.scoring.util |
|---|
| Constructors in edu.uci.ics.jung.algorithms.scoring.util with parameters of type Hypergraph | |
|---|---|
UniformDegreeWeight(Hypergraph<V,E> graph)
Creates an instance for the specified graph. |
| Uses of Hypergraph in edu.uci.ics.jung.algorithms.shortestpath |
|---|
| Fields in edu.uci.ics.jung.algorithms.shortestpath declared as Hypergraph | |
|---|---|
protected Hypergraph<V,E> |
DijkstraDistance.g
|
| Methods in edu.uci.ics.jung.algorithms.shortestpath with parameters of type Hypergraph | ||
|---|---|---|
static
|
DistanceStatistics.averageDistances(Hypergraph<V,E> g)
For each vertex v in g ,
calculates the average shortest path length from v
to all other vertices in g , ignoring edge weights. |
|
static
|
DistanceStatistics.averageDistances(Hypergraph<V,E> graph,
Distance<V> d)
For each vertex v in graph ,
calculates the average shortest path length from v
to all other vertices in graph using the metric
specified by d , and returns the results in a
Map from vertices to Double values. |
|
static
|
DistanceStatistics.diameter(Hypergraph<V,E> g)
Returns the diameter of g , ignoring edge weights. |
|
static
|
DistanceStatistics.diameter(Hypergraph<V,E> g,
Distance<V> d)
Returns the diameter of g using the metric
specified by d . |
|
static
|
DistanceStatistics.diameter(Hypergraph<V,E> g,
Distance<V> d,
boolean use_max)
Returns the diameter of g using the metric
specified by d . |
|
int |
BFSDistanceLabeler.getDistance(Hypergraph<V,E> g,
V v)
Given a vertex, returns the shortest distance from any node in the root set to v |
|
protected void |
BFSDistanceLabeler.initialize(Hypergraph<V,E> g,
Set<V> rootSet)
|
|
void |
BFSDistanceLabeler.labelDistances(Hypergraph<V,E> graph,
Set<V> rootSet)
Computes the distances of all the node from the starting root nodes. |
|
void |
BFSDistanceLabeler.labelDistances(Hypergraph<V,E> graph,
V root)
Computes the distances of all the node from the specified root node. |
| Constructors in edu.uci.ics.jung.algorithms.shortestpath with parameters of type Hypergraph | |
|---|---|
DijkstraDistance(Hypergraph<V,E> g,
Creates an instance of DijkstraShortestPath for
the specified graph and the specified method of extracting weights
from edges, which caches results locally. |
|
DijkstraDistance(Hypergraph<V,E> g,
Creates an instance of DijkstraShortestPath for
the specified graph and the specified method of extracting weights
from edges, which caches results locally if and only if
cached is true . |
|
UnweightedShortestPath(Hypergraph<V,E> g)
Constructs and initializes algorithm |
| Uses of Hypergraph in edu.uci.ics.jung.algorithms.transformation |
|---|
| Methods in edu.uci.ics.jung.algorithms.transformation with parameters of type Hypergraph | ||
|---|---|---|
static
|
FoldingTransformer.foldHypergraphEdges(Hypergraph<V,E> h,
Creates a Graph which is an edge-folded version of h , where
hyperedges are replaced by k-cliques in the output graph. |
|
static
|
FoldingTransformer.foldHypergraphEdges(Hypergraph<V,E> h,
Creates a Graph which is an edge-folded version of h , where
hyperedges are replaced by k-cliques in the output graph. |
|
Graph<E,Collection<V>> |
FoldingTransformer.foldHypergraphVertices(Hypergraph<V,E> h,
Creates a Graph which is a vertex-folded version of h , whose
vertices are the input's hyperedges and whose edges are induced by adjacent hyperedges
in the input. |
|
static
|
FoldingTransformer.foldHypergraphVertices(Hypergraph<V,E> h,
Creates a Graph which is a vertex-folded version of h , whose
vertices are the input's hyperedges and whose edges are induced by adjacent hyperedges
in the input. |
| Uses of Hypergraph in edu.uci.ics.jung.graph |
|---|
| Subinterfaces of Hypergraph in edu.uci.ics.jung.graph | |
|---|---|
interface |
DirectedGraph<V,E>
A tagging interface for implementations of Graph
that accept only directed edges. |
interface |
Forest<V,E>
An interface for a graph which consists of a collection of rooted directed acyclic graphs. |
interface |
Graph<V,E>
A graph consisting of a set of vertices of type V
set and a set of edges of type E . |
interface |
KPartiteGraph<V,E>
An interface for graphs whose vertices are each members of one of 2 or more disjoint sets (partitions), and whose edges connect only vertices in distinct partitions. |
interface |
Tree<V,E>
A subtype of Graph which is a (directed, rooted) tree. |
interface |
UndirectedGraph<V,E>
A tagging interface for extensions of Graph that
accept only undirected edges. |
| Classes in edu.uci.ics.jung.graph that implement Hypergraph | |
|---|---|
class |
AbstractGraph<V,E>
Abstract implementation of the Graph interface. |
class |
AbstractTypedGraph<V,E>
An abstract class for graphs whose edges all have the same EdgeType . |
class |
DelegateForest<V,E>
An implementation of Forest that delegates to a specified DirectedGraph
instance. |
class |
DelegateTree<V,E>
An implementation of Tree that delegates to
a specified instance of DirectedGraph . |
class |
DirectedOrderedSparseMultigraph<V,E>
An implementation of DirectedGraph , suitable for sparse graphs,
that orders its vertex and edge collections
according to insertion time. |
class |
DirectedSparseGraph<V,E>
An implementation of DirectedGraph suitable for sparse graphs. |
class |
DirectedSparseMultigraph<V,E>
An implementation of DirectedGraph , suitable for sparse graphs,
that permits parallel edges. |
class |
GraphDecorator<V,E>
An implementation of Graph that delegates its method calls to a
constructor-specified Graph instance. |
class |
ObservableGraph<V,E>
A decorator class for graphs which generates events |
class |
OrderedKAryTree<V,E>
An implementation of Tree in which each vertex has
<= k children. |
class |
OrderedSparseMultigraph<V,E>
An implementation of Graph that orders its vertex and edge collections
according to insertion time, is suitable for sparse graphs, and
permits directed, undirected, and parallel edges. |
class |
SetHypergraph<V,H>
An implementation of Hypergraph that is suitable for sparse graphs and
permits parallel edges. |
class |
SortedSparseMultigraph<V,E>
An implementation of Graph that is suitable for sparse graphs,
orders its vertex and edge collections according to either specified Comparator
instances or the natural ordering of their elements, and permits directed, undirected,
and parallel edges. |
class |
SparseGraph<V,E>
An implementation of Graph that is suitable for sparse graphs and
permits both directed and undirected edges. |
class |
SparseMultigraph<V,E>
An implementation of Graph that is suitable for sparse graphs
and permits directed, undirected, and parallel edges. |
class |
UndirectedOrderedSparseMultigraph<V,E>
An implementation of UndirectedGraph that is suitable for sparse graphs,
orders its vertex and edge collections according to insertion time, and permits
parallel edges. |
class |
UndirectedSparseGraph<V,E>
An implementation of UndirectedGraph that is suitable
for sparse graphs. |
class |
UndirectedSparseMultigraph<V,E>
An implementation of UndirectedGraph that is suitable for
sparse graphs and permits parallel edges. |
| Uses of Hypergraph in edu.uci.ics.jung.io |
|---|
| Classes in edu.uci.ics.jung.io with type parameters of type Hypergraph | |
|---|---|
class |
GraphMLReader<G extends Hypergraph<V,E>,V,E>
Reads in data from a GraphML-formatted file and generates graphs based on that data. |
interface |
GraphReader<G extends Hypergraph<V,E>,V,E>
Interface for a reader of graph objects |
| Fields in edu.uci.ics.jung.io declared as Hypergraph | |
|---|---|
protected G |
GraphMLReader.current_graph
|
| Fields in edu.uci.ics.jung.io with type parameters of type Hypergraph | |
|---|---|
protected Map<String,GraphMLMetadata<Hypergraph<V,E>>> |
GraphMLWriter.graph_data
|
| Methods in edu.uci.ics.jung.io with parameters of type Hypergraph | |
|---|---|
void |
GraphMLWriter.save(Hypergraph<V,E> graph,
Writer w)
|
protected void |
GraphMLWriter.writeEdgeData(Hypergraph<V,E> g,
Writer w)
|
protected void |
GraphMLWriter.writeVertexData(Hypergraph<V,E> graph,
BufferedWriter w)
|
| Method parameters in edu.uci.ics.jung.io with type arguments of type Hypergraph | |
|---|---|
void |
GraphMLWriter.setGraphData(Map<String,GraphMLMetadata<Hypergraph<V,E>>> graph_map)
Provides a map from data type name to graph data. |
| Uses of Hypergraph in edu.uci.ics.jung.io.graphml |
|---|
| Classes in edu.uci.ics.jung.io.graphml with type parameters of type Hypergraph | |
|---|---|
class |
GraphMLReader2<G extends Hypergraph<V,E>,V,E>
Reads in data from a GraphML-formatted file and generates graphs based on that data. |
| Uses of Hypergraph in edu.uci.ics.jung.io.graphml.parser |
|---|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


| Test Case Number |
Test Case Name |
IE7 |
| 10. XForms Actions |
| 10.a |
action syntax example |
Passed |
| 10.b |
rebuild in action element |
Passed |
| 10.c |
recalculate in action element |
Passed |
| 10.d |
revalidate in action element |
Passed |
| 10.e |
refresh in action element |
Passed |
| 10.f |
insert in action element |
Passed |
| 10.g |
delete in action element |
Passed |
| 10.h |
setvalue in action element |
Passed |
| 10.i |
reset in action element |
Passed |
| 10.1.a |
action element |
Passed |
| 10.2.a |
setvalue elements with expression or literal |
Passed |
| 10.2.b |
setvalue element with expression and literal, element with neither |
Passed |
| 10.3.a |
insert action using context attribute |
Passed |
| 10.3.b |
insert action with bind and model attributes |
Passed |
| 10.3.c |
insert action using origin attribute |
Passed |
| 10.3.d |
insert action using at attribute |
Passed |
| 10.3.e |
insert action using position attribute |
Passed |
| 10.3.f |
insert action in repeat bound to collection |
Failed |
| 10.3.g |
insert action - nodeset indicates root element |
Passed |
| 10.3.h |
insert action and repeat element |
Passed |
| 10.3.i |
insert action - xforms-insert event |
Passed |
| 10.3.j |
insert action - copying an attribute |
Passed |
| 10.4.a |
delete action using context attribute |
Passed |
| 10.4.b |
delete action using context and bind attributes |
Passed |
| 10.4.c |
delete action using context attribute terminates with no effect |
Passed |
| 10.4.d |
delete action using at attribute |
Passed |
| 10.4.e |
delete element rules |
Passed |
| 10.4.f |
delete action and repeat element |
Passed |
| 10.4.g |
delete action with xforms-delete event |
Passed |
| 10.5.a |
setindex element rules |
Passed |
| 10.6.a |
events dispatched by toggle element |
Passed |
| 10.6.1.a |
case element child of the toggle element |
Passed |
| 10.6.1.b |
case element child of the toggle element precedence testing |
Passed |
| 10.7.a |
setfocus element |
Passed |
| 10.7.1.a |
setfocus element with value child element |
Passed |
| 10.7.1.b |
control element precedence tests |
Passed |
| 10.8.a |
dispatch element dispatches predefined event |
Passed |
| 10.8.b |
dispatch element dispatches custom event |
Passed |
| 10.8.c |
dispatch element with delay attribute |
Passed |
| 10.8.d |
dispatch element dispatches custom event that bubbles |
Passed |
| 10.8.e |
dispatch element dispatches cancelled custom event |
Passed |
| 10.8.f |
dispatch element dispatches cancelled predefined event |
Failed |
| 10.8.1.a |
dispatch element with name child element |
Passed |
| 10.8.1.b |
name element has precedence over attribute |
Passed |
| 10.8.1.c |
value attribute has precedence in name element |
Passed |
| 10.8.2.a |
dispatch element with target child element |
Passed |
| 10.8.2.b |
target element has precedence over attribute |
Passed |
| 10.8.2.c |
value attribute has precedence in target element |
Passed |
| 10.8.3.a |
dispatch element with delay child element |
Passed |
| 10.8.3.b |
delay element has precedence over attribute |
Passed |
| 10.8.3.c |
value attribute has precedence in delay element |
Passed |
| 10.13.a |
reset element |
Passed |
| 10.13.b |
reset element with model attribute |
Passed |
| 10.14.a |
load element attributes |
Passed |
| 10.14.b |
show attribute of load element |
Passed |
| 10.14.1.a |
load element with resource child element |
Passed |
| 10.14.1.b |
value attribute has precedence in load element |
Passed |
| 10.15.a |
send element |
Failed |
| 10.16.a |
message element using single node binding |
Passed |
| 10.16.b |
level attribute of message element |
Passed |
| 10.16.c |
message element interface created at run time |
Passed |
| 10.17.a |
conditional execution of XForms actions |
Passed |
| 10.17.b |
conditional execution of XForms actions using action element |
Passed |
| 10.17.c |
conditional execution of XForms actions - Automatic Focus Advancement example |
Failed |
| 10.17.d |
conditional execution of XForms actions - Handling Focus for Empty Repeats example |
Passed |
| 10.18.a |
iteration of XForms actions |
Passed |
| 10.18.b |
iteration of XForms actions using action element |
Passed |
| 10.18.c |
iteration executed zero times |
Passed |
| 10.18.d |
XForms actions with if and while attributes |
Passed |
| 10.18.e |
iteration of XForms actions - Summing Selected Results example |
Passed |


--- layout: post title: Learning Code 1 date: '2016-09-22T14:53:04-04:00' tags: - processing - reblog tumblr_url: https://alexcodes.tumblr.com/post/150782752434/learning-code-1 ---
Last week, I talked to Zach about my desire to learn Processing/P5/OF, and he gave me homework as below:
- draw your name using code (not using fonts, just using geometry)
- take a letter of the alphabet (that’s made of straight lines such as H,T,A) draw it as a series of lines. Can you parameterize any part of the drawing so that you can define the bounding box of the letter (ie, define the x,y,width and height) and it draws to fit the box ?
- use a for loop to make an interesting pattern with geometry.
- create a function for the letter you’ve made (above) and use a for loop to draw this letter multiple times with different settings.
- use a for loop inside of a for loop to draw a grid- create a composition which animates using variables that change over time.
What I did for 1 and 4 (sort of…):
Code History
- Version 1 on Gist
Zach’s feedback: define a width and a height as a variable for the letters- Version 2 on Gist
- Version 3 on Gist
Code History
- Version 1 on Gist
Zach’s feedback: can you pass in width and height as well (and draw ys that change in width and height as well as x/y)- Version 2 on Gist (see image below): after some trials, I made the width and height of Ys increase by 10px for each line.
Reblogged from @ysfpc. Going to attempt these challenges myself. Nice work, Yeseul!


These logs are not stored in plaintext but instead as binaries. Which makes it a bit harder to clear.
who
last
lastlog


Calculator
10
Mail
Video
Pictures
5
Store
6
Music
michael_angiulo
I just saw Thor last night. It was awesome! I think you'd love it.
RT @julie_green
Tweet@rama
YouTube
<EMAIL_ADDRESS>Re: Wedding Annoucement!
Congratulations! I'm really excited to celebrate with you all. Thanks for...
<EMAIL_ADDRESS>Re: Wedding Annoucement!
Huh! Waw!!! I'm really excited to celebrate with you all. Thanks for...
12
Internet Explorer
Excel 2013
Word 2013
OneNote 2013
Photos
This is a desert eagle.


Valentine's Day and the opposite of loneliness
Marina Keegan. Photo from the book The Opposite of Loneliness: Essays and Stories by Marina Keegan. Ms. Keegan died in a car crash just five days after graduating magna cum laude from Yale.
Marina Keegan–a 22 year old–wrote this a few weeks before her college commencement at Yale:
We don’t have a word for the opposite of loneliness, but if we See the complete Opposite of Loneliness essaydid, I could say that’s what I want in life. What I’m grateful and thankful to have found at Yale, and what I’m scared of losing when we wake up tomorrow and leave this place.
It’s not quite love and it’s not quite community; it’s just this feeling that there are people, an abundance of people, who are in this together. Who are on your team. When the check is paid and you stay at the table. When it’s four a.m. and no one goes to bed. That night with the guitar. That night we can’t remember. That time we did, we went, we saw, we laughed, we felt. The hats.
We all, I think, have had similar experiences to hers. The camaraderie of a college experience, of being in the military, of a close-knit group in high school. The feeling that there are people that are in this together. Those are very intense experiences. Imagine what life would be like if we experienced that, every moment of our day. With everyone we meet or see we would have this intense feeling that we are in this together, we are on the same team, with everyone. even people who cut us off in traffic or have an opposing political view.
We would still have sufferings in our life. We might lose our job, have difficulties in a relationship, have sickness, maybe even chronic illness. But we would feel 100% supported and feel that the entire community has our back.
Unfortunately, many of us don’t feel this strong sense of community. Rather we feel loneliness and a sense of separation. Mother Teresa reportedly said: The biggest disease today is not leprosy or tuberculosis but rather the feeling of not belonging Modern society with its emphasis on individualism seems to exasperate this problem by emphasizing the self. In contrast, in Buddhism we work at letting the self fall away and reducing the barriers between ourselves and the rest of the world. Buddhism strives for the opposite of loneliness.
The book we will start discussing next week, Radical Acceptance: Embracing Your Life With the Heart of a Buddha by Tara Brach, presents methods that help us on this path. Please consider joining us for this book study.


This App provides special functions for Pen Making using a Rotary Indexer. This first TAB is a Quick-Start for those who purchased the full "Pen Station Package" from Handibot (and makes use of the pen blanks that come preloaded and ready to run with your Accessory Base).
The second TAB is for General Pen Making projects and for users setting up to do pen making with previously purchased Indexers. It has routines to align the Indexer for pen making work. Additional TABS provide more detailed information and preference-setting for your pen-making work.
SO, if you purchased the full Pen Station Package and you are new to Handibotting, before you set up the Accessory Base and continue along here, you should first familiarize yourself with the operation of your Handibot. Follow the Quick Start instructions and take the "Tour". Try out the controls, run the test file, and maybe try a few things with the tool before you set it up to the start pen-making projects.
After you are comfortable with your Handibot, follow the assembly instructions to mount your Handibot on the Accessory Base. Everything is already set up for you to get quickly started with a Pen-Making project. Follow along here when you are ready.
Use the "Home Tool for Pens" button (below) to set up your tool for creating pens in the Handibot Pen Station Package.
* Before Homing, unplug and remove the Router from the router-bracket and set to one side (if you have not already done so).
In all of the following procedures, Click "Resume" to continue to the next step, unless you have a problem and need to Quit from the procedure.
* After Homing, slid the Router into the bracket and gently lower until cutter-tip just touches mandrel head. Tighten into position (bottom screw first), then plug the Router back in.
You're ready to position tool for cutting the first blank.
After homing, you are ready to run your project, starting with the first blank.
Now, SELECT your Project to start Pen Making!.
Great. If all went well, you've machined your Pen Station Project.

Release the clamps and pull the indexer board out to the ## stop so you will be able to conveniently apply Aussi Oil while spinning the the newly machined parts. Use a soft rag, start with a tablespoon of oil and apply over the spinning parts. Then apply more!
* Click the next button to spin the indexer while you apply the finish. It will automatically spin about 50,000 degrees and back (3 minutes). Click again for more spinning ...
* Congratulations! You've finished machining a Pen Station Project. You're ready to assemble your first pen.
Your imagination is the limit as you begin to explore your creative opportunities in pen making.
This page provides general purpose setup and housekeeping functions for Pen-Making Projects. These will help with alignment and positioning your Handibot for pen-making. You can use the Short Form option (radio-button, below) for simplified access after you get experience with these functions.
If you have not done so... CLICK HERE to Install Pen Making Macros
Start a Pen Making Project
Home the tool to start a pen-making project. The function will automatically Home your Handibot using the normal homing routine (Macro 3) and then it will use the tool's pen-making offsets to center the X axis over the pen mandrel and position the tool for setting your cutter to the correct Z height.
This function assumes that you have used the Indexer Alignment tool, below, and that you have already installed the Macros for Pen-Making projects. Further, you can change the default positioning for these routines in the Preferences Tab. The Detail Tab describes how the various settings and routines all work together.
* Before Homing, unplug and remove the Router from the router-bracket and set to one side (if you have not already done so).
* After Homing, slide the Router into the bracket and gently lower until cutter-tip just touches mandrel head. Tighten into position (bottom screw first), then plug the Router back in.
* You're ready to position tool for cutting the first blank.
The next button will take you to the default start position for the second blank. You will use this for cases where the toolpath files for the two blanks are separate.
Generally useful stuff
You may be just setting up an Indexer for Pen Making, your tool may have been jostled, the mounting of the Handibot or Indexer may be changed from the factory configuration, or something else may have caused the indexer and mandrel to go out of alignment. This routine will check centerline locations of the mandrel for you so you can evaluate whether everything is properly aligned. It will also determine the correct X and Z offsets for the mandre.
Before starting this routine, remove any fittings or bushings from the mandrel. Clamp the tailstock into working location. Then insert 1/4" alignment rod (solid drill rod) into the router. After the rod is in place, you will need to attach the aligator clips to the mandrel as indicated below. Then, use the Keypad to move the drill-rod to the indicated position with the tip about 1/4" below the mandrel. Now, click the Check Alignment button when you are ready.
At the end of the alignment process, you can accept or reject the update of the settings for the X and Z offset positions of the mandrel. These are the settings that determine how the homing and cutter positioning routines will work. These values can also be inspected and/or entered manually in the Preferences tab.
This App is intended to help make the pen-making projects of Handibot's "Pen Station" easy to get started with. Additionally, you'll be able to modify settings and variables here so that you can continue to use much of the functionality with other pen projects or for automating your own pen production work. You don't really need any of these tools for using the indexer or making pens, but we think they help make some of the routine work such as aligning, setting up the tool, and positioning during pen carving more straightforward. And, they provide programming examples if you want to set up this kind of App for yourself.
The last portion of the Pen Making tab is an "alignment" tool to help with aligning the indexer or checking alignment. During the process, location "offsets" are recorded and the user has the option of storing them at the end of the procedure as updated values specific to the tool. These are some of the values that can also be adjusted on the Preferences tab.
This page allows you to monitor and edit the special variables used for Pen Turning. The initial/default values are for the use with the Projects that come with the Pen Station Package from Handibot and should be correct for your Handibot if it was set up at the factory. If you have set up your own indexer for pen making, you will need to use the alignment functions on the "Pen Making" page to correctly set your variables.
Variable preferences are saved using a system of "persistent variables".  The default values for these variables are saved in Macro 60 and can be restored to their original values by running Macro 60.
Make sure to hit the SAVE button after editing any these variables.


| Methods Summary | ||
|---|---|---|
public static
|
||
public static
|
||
public
|
||
public
|
||
public
|
#
authorizeForUser( \Illuminate\Contracts\Auth\Authenticatable|mixed $user , mixed $ability , mixed|array $arguments = array ( ) )
Authorize a given action for a user.
|
|
public
|
||
protected
|
#
throwValidationException( Illuminate\Http\Request $request , \Illuminate\Contracts\Validation\Validator $validator )
Throw the failed validation exception.
|
|
protected
|
||
protected
|
||
protected
|
#
parseAbilityAndArguments( mixed $ability , mixed|array $arguments )
Guesses the ability's name if it wasn't provided.
|
|
protected
|
| Properties Summary | ||
|---|---|---|
protected static
Closure
|
$responseBuilder
The response builder callback.
|
#
NULL
|
protected static
Closure
|
$errorFormatter
The error formatter callback.
|
#
NULL
|


values sulfur nss Dome ice marine biogenic glacial nss-SO {border-style DDU isotopic px;} #ffffff;} Antarctica [SO aerosol period Antarctic nmb isotope samples relative sea source cores Sulfur nmb-SO Supplementary coastal core observed snow sources ./jd Nature Science atmospheric decrease estimate fractionation salt total transport ± % (Fig. . ± .‰ Geophysical composition concentrations ion mode particles px; signature sulfate {font-family (°′S, Atmospheric Legrand November Ocean Research Southern based described estimated font-size increase past periods result sample shows summer surface using CaSO Dumont East Figure However, Savarino cycle cycles data double; emissions flux increased inland nonmarine record records reported used winter (). ./acp--- Chemistry Ishino Note Physics [], \documentclass[pt]{minimal} \setlength{\oddsidemargin}{-pt} \usepackage{amsbsy} \usepackage{amsfonts} \usepackage{amsmath} \usepackage{amssymb} \usepackage{mathrsfs} \usepackage{upgreek} \usepackage{wasysym} activity border-color border-width change changes climate collected compositions deep discussed fine glacial-interglacial http://orcid.org/--- importance interglacial mass mb-SO non-sea-salt present produced productivity radiative range sediment sites sites. solid; variability {font-style {font-weight Alexander Atmospheres Commons Creative DDU, Hattori Institute Research: Sci Scientific Station aerosols analytical annual anthropogenic applied bold ca. concentration consistent contributions cooling courier; data. d’Urville em; fraction low lower oxidation preserved program pt;} ratio respectively, respectively. seasonality standard sulfide time uncertainty value volcanic °′E;


Choose a Level Below to Play
easy
medium
hard
score
00000
rows
0
Back
Music
Sorry, this example cannot be run because your browser does not support the <canvas> element


Johnny Fisher
$745.00
Your Account
Info & Statistics
Author Tools
New Original Visits
Less Sales Than Last Month
Total Visits This Month
Title
Description
Details
Expertise
Visibility
Budget
Review
Description A good description includes:
0/5000 characters (minimum 50)
What type of project do you have?
photoshop flat icon devices mobile vector coffee scene hero image maker set tablet laptop mockup
Who can see your job?
How many freelancers do you need for this job?


My Team
Manager's Name
icon + Manager
ID
EMAIL
OFFICE #
Manager's Name
icon + Manager
ID
EMAIL
OFFICE #
Manager's Name
icon + Manager
ID
EMAIL
OFFICE #
Manager's Name
icon + Manager
ID
EMAIL
OFFICE #
Manager's Name
icon + Manager
ID
EMAIL
OFFICE #


I think it might be good to approach this from the perspective of what we need day-to-day, vs. what would be nice to have, vs. what we might expect at crunch times (e.g., week before production deploy). Something like:
referenced
by Shaun Ellis at 2019-11-05 19:40:12.merged
by Shaun Ellis at 2019-11-05 19:40:12.closed
by Shaun Ellis at 2019-11-05 19:40:12.head_ref_deleted
by Shaun Ellis at 2019-11-05 19:40:14.referenced
by Shaun Ellis at 2019-11-05 19:42:52.merged
by Shaun Ellis at 2019-11-05 19:42:52.closed
by Shaun Ellis at 2019-11-05 19:42:52.head_ref_deleted
by Shaun Ellis at 2019-11-05 19:42:54.head_ref_force_pushed
by None at 2019-11-05 17:37:28.head_ref_force_pushed
by None at 2019-11-05 18:17:34.referenced
by Shaun Ellis at 2019-11-05 19:56:31.merged
by Shaun Ellis at 2019-11-05 19:56:31.closed
by Shaun Ellis at 2019-11-05 19:56:31.head_ref_deleted
by Shaun Ellis at 2019-11-05 19:56:33.Searching by title, DCL code and PUL bib yielded no results in Figgy.
labeled
by None at 2019-11-04 23:44:28.renamed
by James R. Griffin III at 2019-11-05 14:11:20.referenced
by None at 2019-11-05 14:11:35.merged
by None at 2019-11-05 14:11:35.closed
by None at 2019-11-05 14:11:35.referenced
by Esmé Cowles at 2019-11-05 15:44:11.merged
by Esmé Cowles at 2019-11-05 15:44:11.closed
by Esmé Cowles at 2019-11-05 15:44:11.head_ref_deleted
by Esmé Cowles at 2019-11-05 15:44:18.assigned
by Eliot Jordan at 2019-11-05 21:51:28.assigned
by Nikitas Tampakis at 2019-11-05 21:51:28.labeled
by None at 2019-11-06 00:59:31.labeled
by None at 2019-11-06 00:59:31.These are missing, but instead of sending the person to the circulation desk it shows it's old location - https://locator-prod.princeton.edu/index.php?loc=f&id=994986&embed=true - https://locator-prod.princeton.edu/index.php?loc=f&id=1707253&embed=true - https://locator-prod.princeton.edu/index.php?loc=f&id=1287942&embed=true
These are missing and go to the circulation desk - https://locator-prod.princeton.edu/index.php?loc=f&id=2004363&embed=true - https://locator-prod.princeton.edu/index.php?loc=f&id=2930025&embed=true - https://locator-prod.princeton.edu/index.php?loc=f&id=3344112&embed=true
Here is an example of two different call numbers - https://locator-prod.princeton.edu/index.php?loc=f&id=1382929&embed=true https://locator-prod.princeton.edu/index.php?loc=f&id=1382929&embed=true
assigned
by Christina Chortaria at 2019-11-05 20:50:32.head_ref_force_pushed
by None at 2019-11-05 13:53:34.Out dated
closed
by None at 2019-11-05 19:27:12.OK, I won't notify you again about this release, but will get in touch when a new version is available. If you'd rather skip all updates until the next major or minor version, let me know by commenting @dependabot ignore this major version
or @dependabot ignore this minor version
.
If you change your mind, just re-open this PR and I'll resolve any conflicts on it.
closed
by None at 2019-11-05 19:28:53.head_ref_deleted
by None at 2019-11-05 19:29:04.We have updated Figgy to use the dynamic configuration automatically, so we don't need to update the viewer in Pulmap and every other app: https://github.com/pulibrary/figgy/pull/3468
closed
by Esmé Cowles at 2019-11-05 14:58:32.renamed
by Christina Chortaria at 2019-11-05 20:48:23.assigned
by Christina Chortaria at 2019-11-05 20:48:27.The product owners are Faith Charlton and Amanda Ferrara.
closed
by Esmé Cowles at 2019-11-05 14:17:12.will reopen this pr against master
head_ref_force_pushed
by None at 2019-11-05 17:34:32.closed
by None at 2019-11-05 17:44:32.head_ref_force_pushed
by None at 2019-11-05 17:42:30.deployed
by Trey Pendragon at 2019-11-05 17:57:27.head_ref_force_pushed
by None at 2019-11-05 18:39:53.referenced
by James R. Griffin III at 2019-11-05 19:04:03.merged
by James R. Griffin III at 2019-11-05 19:04:03.closed
by James R. Griffin III at 2019-11-05 19:04:03.head_ref_deleted
by James R. Griffin III at 2019-11-05 19:04:06.I technically created this PR but it's really @jrgriffiniii's work; I just had to open this new one because the original was against a branch that has since been merged.
This PR fixes the index and makes it run in sidekiq. Merging for now; creating #59 to fix up rake tasks.
mentioned
by James R. Griffin III at 2019-11-05 20:40:50.subscribed
by James R. Griffin III at 2019-11-05 20:40:50.referenced
by None at 2019-11-05 20:41:01.merged
by None at 2019-11-05 20:41:01.closed
by None at 2019-11-05 20:41:01.VMs are ready.
closed
by Francis Kayiwa at 2019-11-05 14:54:32.referenced
by None at 2019-11-05 19:00:51.merged
by None at 2019-11-05 19:00:51.closed
by None at 2019-11-05 19:00:51.head_ref_deleted
by None at 2019-11-05 19:00:55.head_ref_force_pushed
by None at 2019-11-05 18:31:05.head_ref_force_pushed
by None at 2019-11-05 19:08:17.review_requested
by None at 2019-11-05 19:12:40.review_requested
by None at 2019-11-05 19:12:40.renamed
by None at 2019-11-05 19:12:46.referenced
by James R. Griffin III at 2019-11-05 19:13:19.merged
by James R. Griffin III at 2019-11-05 19:13:19.closed
by James R. Griffin III at 2019-11-05 19:13:19.head_ref_deleted
by James R. Griffin III at 2019-11-05 19:13:23.head_ref_force_pushed
by None at 2019-11-05 19:06:22.mentioned
by Francis Kayiwa at 2019-11-05 19:10:43.subscribed
by Francis Kayiwa at 2019-11-05 19:10:43.review_requested
by None at 2019-11-05 18:45:49.mentioned
by Francis Kayiwa at 2019-11-05 19:13:40.subscribed
by Francis Kayiwa at 2019-11-05 19:13:40.referenced
by Francis Kayiwa at 2019-11-05 19:25:02.merged
by Francis Kayiwa at 2019-11-05 19:25:02.closed
by Francis Kayiwa at 2019-11-05 19:25:02.head_ref_deleted
by Francis Kayiwa at 2019-11-05 19:25:08.referenced
by Christina Chortaria at 2019-11-05 12:14:29.merged
by Christina Chortaria at 2019-11-05 12:14:29.closed
by Christina Chortaria at 2019-11-05 12:14:29.head_ref_deleted
by Francis Kayiwa at 2019-11-05 19:25:34.The PR adds veridian based sites. Since they are all running on the same upstream host they will need to be on the same server blocks. We start with historicperiodicals and blue mountain and their SSL certificates.
@kayiwa , why do you think the bluemountain key(s) are failing? What do we need to do to resolve that?
@kayiwa , why do you think the bluemountain key(s) are failing? What do we need to do to resolve that?
This PR resolves that. It has SSL certs for bluemountain.
review_requested
by Francis Kayiwa at 2019-11-05 12:21:21.mentioned
by Francis Kayiwa at 2019-11-05 13:49:05.subscribed
by Francis Kayiwa at 2019-11-05 13:49:05.mentioned
by Francis Kayiwa at 2019-11-05 14:41:42.subscribed
by Francis Kayiwa at 2019-11-05 14:41:42.head_ref_force_pushed
by Francis Kayiwa at 2019-11-05 14:43:58.referenced
by Cliff Wulfman at 2019-11-05 16:37:53.merged
by Cliff Wulfman at 2019-11-05 16:37:53.closed
by Cliff Wulfman at 2019-11-05 16:37:53.head_ref_deleted
by Francis Kayiwa at 2019-11-05 19:25:36.head_ref_deleted
by Francis Kayiwa at 2019-11-05 19:59:40.review_requested
by None at 2019-11-05 20:13:19.We have updated Figgy to use the dynamic configuration automatically, so we don't need to update the viewer in Pulmap and every other app: https://github.com/pulibrary/figgy/pull/3468
closed
by Esmé Cowles at 2019-11-05 14:58:25.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:15.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:17.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:20.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:35.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:46.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:47.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:49.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:50.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:52.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:54.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:56.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:57.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:31:59.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:32:01.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:32:04.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:32:05.head_ref_deleted
by Kevin Reiss at 2019-11-05 01:32:07.Do these changes make sense? Nearly all the manuscripts are in the Manuscripts Division, Special Collections.
It was Nearly all the manuscripts are in the Manuscripts Division, Department of Special Collections.
Here is another example Reproduction of material housed in the Special Collections must be accompanied by a credit line.
vs Reproduction of material housed in the Department of Special Collections must be accompanied by a credit line.


PSRESIZE(1) PSRESIZE(1) NAME psresize - rescales and centers a document for new output paper size SYNOPSIS psresize [ -wwidth ] [ -hheight ] [ -ppaper ] [ -Wwidth ] [ -Hheight ] [ -Ppaper ] [ -q ] [ infile [ outfile ] ] DESCRIPTION Psresize rescales and centres a document on a different size of paper. The input PostScript file should follow the Adobe Document Structuring Conventions. The -w option gives the output paper width, and the -h option gives the output paper height, normally specified in cm or in to convert Post‐ Script's points (1/72 of an inch) to centimeters or inches. The -p option can be used as an alternative, to set the output paper size to a0, a1, a2, a3, a4, a5, b5, letter, legal, tabloid, statement, executive, folio, quarto or 10x14. The default output paper size is a4. The -W option gives the input paper width, and the -H option gives the input paper height. The -P option can be used as an alternative, to set the input paper size. The default input paper size is a4. Psresize normally prints the page numbers of the pages output; the -q option suppresses this. EXAMPLES The following command can be used to convert a document on A4 size paper to letter size paper: psresize -PA4 -pletter in.ps out.ps AUTHOR Copyright (C) Angus J. C. Duggan 1991-1995 SEE ALSO psbook(1), psselect(1), pstops(1), epsffit(1), psnup(1), psresize(1), psmerge(1), fixscribeps(1), getafm(1), fixdlsrps(1), fixfmps(1), fixps‐ ditps(1), fixpspps(1), fixtpps(1), fixwfwps(1), fixwpps(1), fixwwps(1), extractres(1), includeres(1), showchar(1) TRADEMARKS PostScript is a trademark of Adobe Systems Incorporated. BUGS Psresize does not accept all DSC comments. PSUtils Release 1 Patchlevel 17 PSRESIZE(1)


|
Woo Bum-KonSouth Korean spree killer. Has argument with girlfriend. Being a police officer, Woo Bum-Kon robs the police armory and goes on a drunken 8 hour shooting spree through three villages, leaving 57 dead and 35 wounded before he suicides with two grenades in Uiryong. The Korean interior minister resigns. (28 Apr 1982.) |


145 graves of an African-American cemetery found under school in Florida - The Nation Newspaper
THE graves of 145 people have been discovered under a high school in Tampa, in the US state of Florida.
They are part of Ridgewood Cemetery, a mid-20th Century cemetery for the poor.
The coffins – buried 3-5ft (1-1.5m) deep – were discovered using ground-penetrating radar after the school was alerted about the possible location of the cemetery.
Records indicate more than 250 people were buried there, most of them African Americans, the school district said.
Up to 77 of them were infants or small children.
The city opened Ridgewood in 1942 and sold it off to a private company in 1957. The school district acquired the land in 1959, opening King High School in 1960.
Today, the site consists of open land and the school’s agricultural building.
Plans are being made to have the building removed, according to school district Superintendent Jeff Eakins.”
“We want to make sure that the folks buried at this site are honoured,” he said.
Read Also: Buhari sympathises with leaders of East, Central Africa over deadly floods
While the radar used can’t confirm what exactly is under the surface, the patterns of the findings matched historical records of the cemetery.
As for the graves that have not been accounted for, some may have been moved or not picked up by the radar because they have deteriorated or, in the case of children, their small size.
 This hurts deeply,” Yvette Lewis, president of the local branch of the National Association for the Advancement of Colored People, was quoted as saying by the Tampa Bay Times.
“It was hate toward people who looked like me. It deeply saddens me that people can hate you this much, that they can treat you less than.”


Dragon names from Skyrim, shown by max level. Hover over text to toggle between english & dovah names. Yes, this is not very insightful, but it was fun!
Dovahzul font courtesy of Thuum.org Data courtesy of UESP.net


Dialogue in the Dark
Duration
4 weeks
Type
Integrated Campaign
Print / OOH
Tools
Photoshop
Role
Art Director
The dialogue in the dark exhibition is an experience like no other. The exhibitions provide an opportunity for people to learn from blind guides firsthand. You need to rely on your other senses in the pitch darkness. The exhibition aims to change mindsets on disability and diversity, and increase tolerance for “otherness”. I visited the exhibit while in Hong Kong and it profoundly impacted the way I saw the world. For a project in my creative sequence, my partner and I wanted to see how we could create a campaign to bring more exposure to this often misunderstood topic.
Process
Designing with emphathy
Listen
Hear their stories
Think
Synthesize the research and find meaning
Ideate
Brainstorm ideas and integrate feedback
Share
Share what we learned
As we brainstormed how we could bring awareness to this cause, we
realized that we needed to first assess DITD's brand voice.
Dialogue in the Dark's mission to increase tolerance and change
our views on disability and diversity was what particularly stood
out to us.
The more we researched and listened to interviews the more we
realized that our tone should convey DITD's message of
empowerment. In the end our messaging wasn't complicated, we
simply wrote facts out in plain sight, but with tinted black text
that played off of DITD's pitch dark exhibitions.
To some, this is just a piece of black paper
But our blind guides feel the extra .3mm thickness
See differently
View nature through scent
2015
National Student ADDYS Gold
2014
Graphis Print Award
2015
The DOTS UK Featured Work
Takeaway
Learnings
In hindsight, I've realized this campaign was my first
experience using human-centered design thinking. The sensitive
yet important issues we worked with led us to focus on how the
user will interact with our ideas and message.
A concern that came up at times as we iterated our designs was
whether viewers "would get it?". Was this too simple? Are we
saying enough? But as we shared our ideas with our peers and
mentor, these worries dissipated. I realized that sometimes
people like to think, and tapping into their curiosity is
sometimes more powerful than spelling things out.


I recently completed an AAS in computer information systems from Arapahoe Community College. While completing my studies I worked as a 911 operator for the City of Denver. I really enjoy programming and look forward to working in the field. I decided to enroll in boot camp as a way to immerse myself in the work and build a portfolio. In my free time, I like to read, watch British TV shows, and travel. It is my goal to travel to six of the seven continents and see the seven wonders of the world. So far I have been to four continents, Europe, Africa, South America and North America. I have visited two wonders of the world, Machu Picchu and the Grand Canyon. I am very much looking forward to my next chapter!