Tilt Shift – Imitates the color saturation of Nikon's miniature fake mode

Nikon's "miniature fake" camera optimization seems to produce selective horizontal / vertical blur (with a drop zone), increase saturation, and increase contrast. There are more robust solutions for imitating tilt-shift DoF than for the camera, so I would rather use them. But I can not quite repeat the saturation / contrast effect at my end. Here is an example –

Original picture

And with the miniature fake tweak –

Miniature forgery

bash – alt + shift + n Keyword int terminal

I found something strange in Bash.

Does anyone know what to do Shift + Alt + N to do in a bash?

When I press these buttons, it writes first :, and if I press it again, it writes ^[N[N[N[N, (The same with alt + shift + p).

With alt + shift + { It shows all the files as a special array (test it, you'll understand why it's special) and use it alt + shift +, it writes traceroute google.com (I think it's one of my previous commands, but why alt + shift +, Show this command?).

I searched a lot, but found nothing.

GUI design – what explains the current shift from shiny UI to dull UI?

It's a shame nobody mentioned the impact of the Mac OS X Aqua interface on all of this.

Aqua was the name Apple gave to the user interface style introduced in Mac OS X. He changed the Mac software as follows:

Screenshot of the MacOS 9 Finder demonstrating the Platinum UI style

… To look like this:

Screenshot of the Mac OS X Finder demonstrating the Aqua UI style

This is Steve Jobs's first introduction to MacWorld San Francisco 2000. As he says

One of the design goals was when you saw it, you wanted it lick it,

There is no doubt that a big influence on the appearance of Aqua with all its delicious buttons, pinstripes and its transparency was the great popularity of the iMac:

The iMac G3 features colored plastic, pinstripes on white and translucency

Aqua was a big change in the UIs; They were no longer drawn by the operating system, but mainly as layers and layers of bitmap (or even vector) graphics. Windows XP followed the same idea in 2001. Your Luna user interface looked like this:

Screenshot of Windows XP with the Luna-UI style

When it was released, Aqua made a similar splash as the iMac when it was released. It felt like every single element of third-party designers would have had some unnecessary shine over the next five years:

Some examples of glossy bubble icons on the Internet

Despite the popularity of translucent and glossy plastic aesthetics, Apple's hardware designs have increasingly withheld over time:

Photos of iMac designs from the original G3 model to the first aluminum iMac

The unstoppable march of material design, simplification and style of hardware had a similar impact on the software – with reduced transparency, diminishing visibility of the pinstripes until they completely disappeared, introduction of brushed metal interfaces, to something else to the old, predominantly gray interface of MacOS 9:

Screenshot of Mac OS X 10.2 Jaguar, which shows how the user interface has been weakened compared to previous versions

Screenshot of Mac OS X 10.3 Panther showing the massive expanse of brushed metal

Screenshot of Mac OS X 10.4 Tiger, which shows the reintroduction of more shine, eg. in the menu bar

Screenshot of Mac OS X 10.5 Leopard showing the integration of brushed metal and aqua to form the predominantly gray user interface

This change is neither specific nor specific to the Mac. It happened throughout the industry.

In the meantime, iOS was released (called the iPhone OS at the time), which looked like this:

Screenshot of iPhone OS v1.0

And as you almost certainly know, the iPhone and iOS itself have been hugely successful. Many, many applications (including Skype) have been released with the glossy symbol overlays to be appropriate alongside these symbols.

Just as Mac OS X looked exciting and refreshing for years, this screenshot of the original iPhone OS screen is now 6 years old and looks like this:

Screenshot of iOS v6.0

As you can undoubtedly see, there has been an unusually slow progress when it comes to the look and feel of Apple's mobile offering.

The old adage is something like this:

If you do not improve, go back

And so two of Apple's key competitors in this area (Google with Android and Microsoft with Windows Phone) took the opportunity to do something radically different and improve the state of the art themselves. make it look like this:

Screenshot of Android v4.0 Ice Cream Sandwich

Screenshot of Windows Phone 7


Update: I just thought I would add a little bit more to the Android languages ​​"Holo" and Metro and how designers and designers describe the flatter, less shiny aesthetic:

When it announced the metro design language (or what it now calls the "Microsoft design language"), Microsoft made some thinly veiled jabs on Apple's shining iOS aesthetic. They also claim that Metro's flatter, more typographic design style is "more honest" and "authentically digital." On the Windows Phone Design Principles website, Microsoft expressly states:

Create a clean and focused experience by leaving only the most relevant elements on the screen.
When designing great app experiences, we believe in content, not chrome.

Concentrating on content on Chrome reduces unnecessary content to make the content of your app shine. Let people immerse themselves in what they love and explore the rest.

You will realize later:

Being authentically digital means going beyond the rules and characteristics of the physical world to create new and exciting possibilities in a purely digital space. Make full use of the digital medium.

Be "infographic". Providing information is the primary goal, not the wrapper. By using the infographic approach, you can optimize the user experience on Windows Phone

Regarding the redesign of their logo, Microsoft relies again on the grounds to be "authentically digital" to eliminate the glare:

It was important that the new logo carries the metro principle "Authentically Digital". By this we mean that there is no attempt to simulate faux-industrial design features such as materiality (glass, wood, plastic, etc.).

Unfortunately, Google did not make their intentions when creating Holo very clear. While they have definitely moved strongly towards the so-called flat design style, they have not made it very clear why. With regard to symbols (which form the core of your question) they simply say:

Use a unique silhouette. Three-dimensional front view, with a slight perspective as seen from above, so that the user perceives some depth.

However, they go deeper into their developer documentation where they say (highlighting mine):

Image from the Google Developer Guidelines, which shows what not to do with gloss
Icons should not be cropped. Use unique shapes if necessary. Remember that startup icons should differentiate your application from others. In addition, Do not use a shiny finish unless the object is shiny,

Their earlier design guidelines from Gingerbread and earlier versions (i.e., Pre-Holo) also explicitly mention the texture ("Icons should contain non-glossy, textured material"), with the full description of the materials described as such:

Launcher icons should use tactile, textured materials with top light. Even if your symbol is just a simple shape, you should try to render in a way that makes it appear as if it's made of a material of the real world.

…and later…

Android Launcher icons are …

  • Modern, minimal, matt, tactile and structured
  • Forward facing and illuminated from above, limited in total to the color palette

Android Launcher icons are not …

  • Antique, over-complicated, shiny, flat vector
  • Turned, cut off, oversaturated

Clearly, Google and Microsoft intend to use the latest mobile operating systems to avoid the aesthetics of iOS / Aqua / glossy.

18.04 – Sticky Keys: The Shift key will start after standby mode in locked mode

I activated Sticky Keys after an injury that prevents me from tapping my left hand.

I have a strange behavior with the shift key when I come from standby mode and standby mode.

When I wake up my laptop (by opening the lid), the Shift key is started in a "locked" state (as if it was pressed twice in a row). When I wake it up from the Suspend state (after using the Suspend option in the Unity Gang menu), the Shift key is pressed once.

I'm on Ubuntu 18.04 with Unity 7.5.0 as my desktop. I have installed Indicator-xkbmod from ppa: nilarimogard / webupd8 to tell me the status of the keys.

What can I do to prevent the Shift key from being woken up when I wake up my laptop? It can be really annoying if I forget it (that's all the time).

Graphics – midpoint shift creates unsatisfactory terrain

Following this lesson to implement a mid-point shift algorithm for terrain generation. I want to create a wavefront file (obj) of the terrain

I have an array of dimension (2 ^ n + 1) x (2 ^ n + 1).
The corners of the 2D array are initialized with random numbers.

n = plug_in_n
arr = Array.new (2 ** n + 1) {Array.new (2 ** n + 1) {0}}
n_augmented = 2 ** n

arr[0][0]    = edge (10 + 1)
arr[0][n_augmented]    = edge (10 + 1)
arr[n_augmented][0]    = edge (10 + 1)
arr[n_augmented][n_augmented]    = edge (10 + 1)

This is the script I wrote to create a terrain.

a = arr
n_augmented_copy = n_augmented
while n_augmented> 1

set "n_augmented =" + n_augmented.to_s
i = 0
while (i <n_augmented_copy)
j = 0
while (j <n_augmented_copy)
on[i][j+(n_augmented)/2]    = (a[i][j]    + a[i][j+n_augmented]) / 2.0 + (margin 0.0..1.0)
on[i + (n_augmented) / 2][j + n_augmented]    = (a[i][j + n_augmented]    + a[i + n_augmented][j + n_augmented]) / 2.0 + (margin 0.0..1.0)
on[i + n_augmented][j +( n_augmented) / 2]    = (a[i + n_augmented][j]    + a[i + n_augmented][j + n_augmented]    ) / 2.0 + (margin 0.0..1.0)
on[i + (n_augmented) / 2][j]        = (a[i + n_augmented][j]    + a[i][j]    ) / 2.0 + (margin 0.0..1.0)
on[i + (n_augmented) / 2][j +( n_augmented) / 2]    = ((a[i][j+(n_augmented)/2]    + a[i + (n_augmented) / 2][j + n_augmented]    + a[i + n_augmented][j +( n_augmented) / 2]        + a[i + (n_augmented) / 2][j])) / 4.0 + (rand 0.0..1.0)
j = j + n_augmented
The End
i = i + n_augmentiert
The End
#tie
# p_arr (a)
n_augmented = n_augmented / 2

The End

Demonstrate a case for n = 2: I omitted the random shift Margin 0.0..1.0to check if the heightmap chucks are finely calculated.

This is how the iterations look like

n_augmented = 4
9 0 5,5 0 2
0 0 0 0 0
6.5 0 5.5 0 4.5
0 0 0 0 0
4 0 5,5 0 7
n_augmented = 2
9 7.25 5.5 3.75 2
7.75 6.625 5.5 4.375 3.25
6.5 6.0 5.0 5.0 4.5
5.25 5.375 5.5 5.625 5.75
4 4.75 5.5 6.25 7 

If I form a net with this net, a level results like:
Enter the image description here

Considering the random shift for this case, this leads to:
Enter the image description here

For n = 5 it looks like this:
Enter the image description here

This is not desirable because I can not see peaks and slopes.

Here's the ruby ​​script: CODE

Performance – Visual Basic for Applications – Array – Push | Pop | Shift | shift

I want to procedurally write my snake game and use as many windows as possible to practice. GetAsyncKeyState lets you capture keystrokes and play sound features. Also create a cute UI. Fun!

Shout to Bytecomb too, to give an example of how to traverse the array structure, and uses its code function to find ptr by element in array !!

Wrote that to practice!

DECLARATIONS AND FUNCTIONS

Option explicitly

Private Declare PtrSafe function VarPtrArray Lib "VBE7" Alias ​​"VarPtr" _
(ByRef Var () As Any) As LongPtr

Private Declare PtrSafe Sub CopyMemoryI Lib "kernel32.dll" Alias ​​"RtlMoveMemory" _
(ByVal dst as LongPtr, ByVal source as LongPtr, ByVal length as length)

Private Declare PtrSafe Sub CopyMemoryII Lib "kernel32.dll" Alias ​​"RtlMoveMemory" _
(ByRef dst As SAFEARRAY, ByVal src As LongPtr, ByVal length so long)

Private type SAFEARRAY_BOUND
cElements for so long
Tied so long
End Type

Private type SAFETY
cDims As Integer
fFeatures as an integer
cbElements so long
cLocks for so long
pvData As LongPtr
rgsabound (0) As SAFEARRAY_BOUND
End Type

Private Type Snake Party
Column so long
Line as long
End Type

Private Const SNAKEPART_BYTELENGTH = 8
Private SnakeParts () as SnakePart

Private Function ArrayPush (ByRef ArrayOriginal () as SnakePart, ByRef ElementToAdd as SnakePart) as SnakePart ()
Dim NewLength So long
Dim Copied Bytes As Long
Dim NewBytes so long

NewLength = UBound (ArrayOriginal) + 1
ReDim ArrayPush (NewLength)

CopiedBytes = UBound (ArrayOriginal) * SNAKEPART_BYTELENGTH
NewBytes = SNAKEPART_BYTELENGTH

CopyMemoryI ArrayElementGetPointer (ArrayPush, 0, SNAKEPART_BYTELENGTH), ArrayElementGetPointer (ArrayOriginal, 0, SNAKEPART_BYTELENGTH), CopiedBytes
CopyMemoryI ArrayElementGetPointer (ArrayPush, UBound (ArrayPush) - 1, SNAKEPART_BYTELENGTH), VarPtr (ElementToAdd), NewBytes
End function

Private Function ArrayPop (ByRef ArrayOriginal () As SnakePart) As SnakePart ()
Dim NewLength So long
Dim Copied Bytes As Long

NewLength = UBound (ArrayOriginal) - 1
ReDim ArrayPop (NewLength)

CopiedBytes = NewLength * SNAKEPART_BYTELENGTH

CopyMemoryI ArrayElementGetPointer (ArrayPop, 0, SNAKEPART_BYTELENGTH), ArrayElementGetPointer (ArrayOriginal (), 0, SNAKEPART_BYTELENGTH), CopiedBytes
End function

Private Function ArrayShift (ByRef ArrayOriginal () as SnakePart, ByRef ElementToAdd as SnakePart) as SnakePart ()
Dim NewLength So long
Dim Copied Bytes As Long
Dim NewBytes so long

NewLength = UBound (ArrayOriginal) + 1
ReDim ArrayShift (NewLength)

CopiedBytes = UBound (ArrayOriginal) * SNAKEPART_BYTELENGTH
NewBytes = SNAKEPART_BYTELENGTH

CopyMemoryI ArrayElementGetPointer (ArrayShift, 1, SNAKEPART_BYTELENGTH), ArrayElementGetPointer (ArrayOriginal, 0, SNAKEPART_BYTELENGTH), CopiedBytes
CopyMemoryI ArrayElementGetPointer (ArrayShift, 0, SNAKEPART_BYTELENGTH), VarPtr (ElementToAdd), NewBytes
End function

Private Function ArrayUnshift (ByRef ArrayOriginal () As SnakePart) As SnakePart ()
Dim NewLength So long
Dim Copied Bytes As Long

NewLength = UBound (ArrayOriginal) - 1
ReDim ArrayUnshift (NewLength)

CopiedBytes = NewLength * SNAKEPART_BYTELENGTH

CopyMemoryI ArrayElementGetPointer (ArrayUnshift, 0, SNAKEPART_BYTELENGTH), ArrayElementGetPointer (ArrayOriginal, 1, SNAKEPART_BYTELENGTH), CopiedBytes
End function

Private Function ArrayElementGetPointer (ByRef Arr () As SnakePart, ByVal ElementIndex As Long, ByVal ElementByteLength As Long) As LongPtr
Dim ptrToArrayVar As LongPtr
Dim ptrToSafeArray As LongPtr
Dim ptrToArrayData As LongPtr
Dim ptrCursor As LongPtr
Dim the SAFEARRAY as SAFEARRAY

# Retrieve pointer in array * variable *
ptrToArrayVar = VarPtrArray (Arr)
& # 39; retrieve pointer to array variable * SAFEARRAY * By directly reading array variable
CopyMemoryI VarPtr (ptrToSafeArray), ptrToArrayVar, 8
Read the SAFEARRAY structure
CopyMemoryII uSAFEARRAY, ptrToSafeArray, LenB (USA)
& # 39; Get pointer to array data
ptrToArrayData = uSAFEARRAY.pvData
Holen Get pointer to array element
ptrCursor = ptrToArrayData + (ElementIndex * ElementByteLength)
ArrayElementGetPointer = ptrCursor
End function

TESTING

Subtest functions ()

Dim Arr (10) As Snake Part
Eclipse SP as SnakePart
SP.Column = 4
SP.Row = 4
Arr (0) = SP
Debug.Print "Expect 4 x2"
Debug.Print Arr (0) .Column
Debug.Print Arr (0) .Row

Dim ArrTwo () as SnakePart

SP.Column = 8
SP.Row = 8
ArrTwo = ArrayPush (Arr, SP)

Debug.Print "Expect 4x2, followed by 8x2"
Debug.Print ArrTwo (0) .Column
Debug.Print ArrTwo (0) .Row
Debug.Print ArrTwo (10) .Column
Debug.Print ArrTwo (10) .Row

ArrTwo = ArrayPop (Arr)

Debug.Print "Expect 4x2, followed by 0x2"
Debug.Print ArrTwo (0) .Column
Debug.Print ArrTwo (0) .Row
Debug.Print ArrTwo (9) .Column
Debug.Print ArrTwo (9) .Row

SP.Column = 7
SP.Row = 7
ArrTwo = ArrayShift (ArrTwo, SP)

Debug.Print "Expect 7x2, followed by 4x2"
Debug.Print ArrTwo (0) .Column
Debug.Print ArrTwo (0) .Row
Debug.Print ArrTwo (1) .Column
Debug.Print ArrTwo (1) .Row

ArrTwo = ArrayUnshift (ArrTwo)

Debug.Print "Expect 4x2, followed by 0x2"
Debug.Print ArrTwo (0) .Column
Debug.Print ArrTwo (0) .Row
Debug.Print ArrTwo (1) .Column
Debug.Print ArrTwo (1) .Row

End Sub

history – Which developer has set the precedent for using the shift key for security (or skip) at startup?

Which developer created the precedent?

I started asking myself after I had reminded that Mozilla Firefox will start in safe mode when shift is held at application Start time. Predecessor … I am sure that Netscape Communications Corp. did not set the precedent since the first version of Netscape Navigator was released in 1994.

For Apple Computer, Inc. and uses of shift at or after system Startup, the first references I can find come from November 1991 and August 1992 (I started using Macs in January 1993). or:

… Peter Crownfiefd (about Zmac). …

… Found that holding the Shift key during startup not only bypasses the system extensions, but also bypasses items in the Start Items folder. If you want to load your extensions, but not the files in the Start Items folder, wait for all of your extensions to load and you will see the message "Welcome to Macintosh" and press the Shift key. Hold down the Shift key until the desktop appears. …

– https://archive.org/stream/MacUser9111November1991/MacUser_9111_November_1991_djvu.txt

… To block the opening of items in the System Startup Items folder of System 7, press the Shift key when the Finder menu headings appear for the first time in the menu bar during startup. To prevent additional loading of extensions from the Extensions folder. Press the SHIFT key and press Shift when the smiling Mac icon appears at the top of the startup sequence. You can release the Shift key after the message "Welcome to Macintosh" appears. …

– https://archive.org/stream/MacWorld_9208_August_1992/MacWorld_9208_August_1992_djvu.txt

Has Apple set the precedent?

Shortcuts – Google Docs Ctrl + Shift + L does not work

So Ctrl + shift + L does nothing in Google Docs, where Ctrl + shift + R and Ctrl + shift + e Job. I tried this on the same Google Doc but on my Chromebook, and it works. My laptop is Windows 10, so I thought something must be shortcut Ctrl + shift + L on my laptop overwriting the Google document, except that nothing happens. Is there a way to solve it?