1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
package main
import (
"encoding/json"
"fmt"
"github.com/gorilla/mux"
"io/ioutil"
"log"
"math/rand"
"net/http"
"os"
"strconv"
"time"
)
type point struct {
x, y, z float64
}
// make a request to the nfw api and return the result
func netNFW(x float64, y float64, z float64) (float64, error) {
var nfwurl = os.Getenv("nfwurl")
if nfwurl == "" {
log.Println("no nfwurl given! set one using the nfwurl environment variable!")
return -1, nil
}
// build the request string
var randMinRequestURL string = fmt.Sprintf("http://%s/NFW?x=%f&y=%f&z=%f", nfwurl, x, y, z)
// make the request
resp, err := http.Get(randMinRequestURL)
if err != nil {
panic(err)
}
// close the request body when finished
defer resp.Body.Close()
// read the body
body, bodyerr := ioutil.ReadAll(resp.Body)
if bodyerr != nil {
panic(bodyerr)
}
var dat map[string]interface{}
jsonerr := json.Unmarshal(body, &dat)
if jsonerr != nil {
panic(jsonerr)
}
result := dat["NFW"].(float64)
return result, nil
}
func gen(galaxyRange float64) point {
// Define variables
var length float64 = galaxyRange
// define the range of the galaxy
var rangeMin float64 = -length
var rangeMax float64 = length
// get the minimal NFW value
var randMin, errGetMinValue = netNFW(0, 0, 0)
if errGetMinValue != nil {
panic(errGetMinValue)
}
// get the maximal NFW value
var randMax, errGetMaxValue = netNFW(length, length, length)
if errGetMaxValue != nil {
panic(errGetMaxValue)
}
var starFound bool = false
for starFound == false {
// define a new random source (without this, the numbers would not be random!)
randomSource := rand.New(rand.NewSource(time.Now().UnixNano()))
// generate random coordinates
var x float64 = ((rangeMax - rangeMin) * randomSource.Float64()) + rangeMin
var y float64 = ((rangeMax - rangeMin) * randomSource.Float64()) + rangeMin
var z float64 = ((rangeMax - rangeMin) * randomSource.Float64()) + rangeMin
// generate a random value in the (randmin, randmax) range
var randomValue = randomSource.Float64()
var randVal = ((randMax - randMin) * randomValue) + randMin
// calculate the nfw-value of the previously generated star
var nfwVal, err = netNFW(x, y, z)
if err != nil {
panic(err)
}
// check if th star should be kept or not
if randVal < nfwVal {
var newStar point = point{x, y, z}
starFound = true
return newStar
}
}
// if no star is found at all, return (0, 0, 0)
// this code should actually never be reached
return point{0, 0, 0}
}
func generate(w http.ResponseWriter, r *http.Request) {
params := r.URL.Query()
amount, _ := strconv.ParseInt(params.Get("num"), 10, 64)
galaxyRange, _ := strconv.ParseFloat(params.Get("range"), 64)
// generate the given amount of stars
for i := 0; i < int(amount); i++ {
result := gen(galaxyRange)
log.Printf("galaxy range: %f", galaxyRange)
log.Printf("%v\n", result)
_, err := fmt.Fprintf(w, "%f, %f, %f\n", result.x, result.y, result.z)
if err != nil {
panic(err)
}
}
}
func indexHandler(w http.ResponseWriter, r *http.Request) {
_, _ = fmt.Fprintf(w, "Generator container here!\nUse the /gen endpoint to generator a star!")
}
func main() {
router := mux.NewRouter()
router.HandleFunc("/", indexHandler).Methods("GET")
router.HandleFunc("/gen", generate).Methods("GET")
log.Fatal(http.ListenAndServe(":8123", router))
}
|
